Wdrażanie w Kubernetes: Kompleksowy przewodnik
Kubernetes, cieszący się dużą popularnością w środowisku programistów, to powszechnie stosowana platforma do uruchamiania kontenerów Docker w klastrach. Ta potężna platforma oferuje różne metody wdrażania i aktualizowania aplikacji działających w kontenerach, zapewniając tym samym wysoki poziom elastyczności w różnych scenariuszach. W Kubernetes kontenery działają w podach, a ich wdrażanie definiują obiekty Kubernetes Deployments. W tym wpisie na blogu omówiono obiekty Kubernetes Deployments, ich rodzaje, strategie wdrażania oraz najlepsze rozwiązania.
Czym jest wdrażanie w Kubernetes?
Wdrażanie w Kubernetes to obiekt zasobów, który zarządza wdrażaniem i cyklem życia aplikacji kontenerowych w klastrach. Zapewnia ono aktualizacje aplikacji, gwarantując, że wymagana liczba identycznych podów działa i jest dostępna przez cały czas. Zapewnia również aktualizacje deklaratywne dla podów i zestawów replik. Wdrażania są kluczową funkcją w Kubernetes, służącą do automatyzacji skalowania, aktualizacji stopniowych i przywracania poprzednich stanów.
Wdrażanie to obiekt Kubernetes, który określa pożądany stan podów oraz tworzy i zarządza zestawami replik (ReplicaSets), aby zapewnić utrzymanie tego stanu. Zestaw replik (ReplicaSet) zarządza podami bezpośrednio, w tym ich stanem i liczbą. Wdrażanie informuje Kubernetes, jak modyfikować lub tworzyć instancje podów, które zawierają kontenery z aplikacjami. Stan wdrażania poda jest opisany w manifeście.
Administratorzy mogą efektywnie skalować liczbę podów replik, wdrażać zaktualizowany kod aplikacji z wysokim poziomem kontroli oraz w razie potrzeby przywracać wcześniejsze wersje wdrażania. Aby zarządzać wdrażaniami Kubernetes, administratorzy używają narzędzia wiersza poleceń kubectl w systemie Linux i innych obsługiwanych systemach operacyjnych. Każdy pod utworzony za pomocą wdrażania ma zestaw replik powiązany z tym podem. Zestaw replik z kolei ma wskaźnik do wdrażania, które utworzyło ten zestaw replik.
Podstawy wdrażania Kubernetes
Wdrażania Kubernetes zostały opracowane w celu wdrażania i skalowania aplikacji kontenerowych w klastrach. Wdrażania zapewniają deklaratywny sposób definiowania pożądanego stanu aplikacji oraz automatyzacji procesu osiągania i utrzymywania tego stanu. Podstawowe pojęcia i komponenty związane z wdrażaniami Kubernetes to:
Desired state. Wdrażanie definiuje pożądany stan aplikacji, taki jak liczba replik poda, obrazy kontenerów do użycia oraz zasoby przydzielone do każdego poda.Declarative configuration. Wdrażania zazwyczaj wykorzystują podejście deklaratywne, w którym administratorzy określają stan w pliku JSON lub YAML. Podczas gdy podejście imperatywne pozwala administratorom bezpośrednio określać, co należy zrobić, podejście deklaratywne w Kubernetes pozwala administratorom zdefiniować wymagany wynik, a Kubernetes osiągnie go za pomocą swoich wewnętrznych mechanizmów. Kontroler wdrażania Kubernetes monitoruje stan węzłów i podów. Jeśli wystąpią zmiany w czasie rzeczywistym, takie jak awaria poda, pod ten może zostać zastąpiony. W ten sposób Kubernetes monitoruje stan klastra w czasie rzeczywistym i wprowadza korekty, aby dostosować go do stanu docelowego.ReplicaSet. Wdrażanie zarządza ReplicaSetem. ReplicaSet tworzy i usuwa pody w miarę potrzeb, aby utrzymać pożądaną liczbę replik. Takie podejście pozwala Kubernetesowi zapewnić, że określone repliki podów działają w dowolnym momencie.Rolling updates. Wdrażanie obsługuje aktualizacje stopniowe, co pozwala na aktualizację aplikacji bez przestojów. Kubernetes stopniowo zastępuje stare pody nowymi, co pomaga zapewnić, że aplikacja w kontenerach pozostaje dostępna podczas procesu aktualizacji wdrażania.Rollback. Jeśli podczas aktualizacji w Kubernetes coś pójdzie nie tak, można przywrócić poprzednią wersję wdrażania, przywracając aplikację do stanu, o którym wiadomo, że działa poprawnie.
Konfiguracja deklaratywna
W Kubernetes podejście deklaratywne oznacza, że określasz pożądany stan systemu, a Kubernetes podejmuje niezbędne działania, aby osiągnąć i utrzymać ten stan. Określasz cel końcowy za pomocą plików konfiguracyjnych (zazwyczaj napisanych w YAML lub JSON), a Kubernetes nieustannie dba o to, by stan rzeczywisty odpowiadał stanowi pożądanemu.
Podejście deklaratywne jest ogólnie preferowane w Kubernetes, ponieważ pozwala utrzymać spójność pożądanego stanu, ułatwia automatyzację oraz wspiera lepszą współpracę i kontrolę wersji. Podejście imperatywne może być przydatne w przypadku szybkich, doraźnych zadań, ale jest mniej odpowiednie do zarządzania złożonymi, długoterminowymi wdrażaniami aplikacji.
Jak współdziałają wdrażania, pody i zestawy replik
W Kubernetes wdrażania, pody i zestawy replik są ściśle powiązanymi komponentami, które wspólnie zarządzają wdrażaniem, skalowaniem i cyklem życia aplikacji. Aby zapewnić prawidłową konfigurację, ważne jest zrozumienie relacji między nimi oraz wiedzy na temat ich współdziałania w Kubernetes.
-
Podjest najprostszym i najmniejszym obiektem w klastrze Kubernetes i reprezentuje pojedynczą instancję uruchomionego procesu. Pod może zawierać jeden lub więcej kontenerów, które współdzielą te same woluminy pamięci masowej i przestrzeń nazw sieciowych. Pods są z założenia efemeryczne, ponieważ mogą być tworzone i niszczone w zależności od potrzeb, aby dopasować się do pożądanego stanu określonego przez obiekty wyższego poziomu, takie jak wdrażanie. -
ReplicaSetzapewnia, że w dowolnym momencie działa określona liczba identycznych Pods. Zarządza on tworzeniem i usuwaniem podów w celu utrzymania pożądanej liczby replik. Każdy zestaw replik (ReplicaSet) wykorzystuje selektory etykiet do identyfikacji i zarządzania podami, które znajdują się pod jego kontrolą, zapewniając utrzymanie właściwych podów. Chociaż można bezpośrednio tworzyć zestawy replik i nimi zarządzać, zazwyczaj są one zarządzane przez wdrażania (Deployments), które zapewniają dodatkowe funkcje. - Wdrażanie (
Deployment) to obiekt Kubernetes wyższego poziomu, który zarządza zestawami replik i zapewnia deklaratywne aktualizacje aplikacji. Wdrażanie pozwala administratorom zdefiniować wymagany stan aplikacji oraz inne ustawienia, jak wyjaśniono powyżej.
Podczas tworzenia lub aktualizacji wdrażania automatycznie tworzony jest nowy ReplicaSet w celu zarządzania podami zgodnie z określonymi specyfikacjami. Za każdym razem, gdy aktualizujesz Deployment, tworzony jest nowy ReplicaSet do obsługi nowej wersji Podów, podczas gdy stary ReplicaSet pozostaje aktywny do momentu pomyślnego wdrożenia nowych Podów. Zapewnia to wdrażanie aktualizacji w sposób kontrolowany, przy zachowaniu dostępności aplikacji.
Deployment zarządza cyklem życia Podów pośrednio poprzez swoje ReplicaSets. Definiując pożądany stan w Deployment, określasz cechy i liczbę Podów, które chcesz uruchomić. Wdrażanie zapewnia następnie ten stan poprzez zarządzanie odpowiednimi ReplicaSetami, które z kolei zarządzają podami.
W ten sposób pody są jednostkami wykonawczymi uruchamiającymi kontenery, ReplicaSety zapewniają uruchomienie wymaganej liczby podów, a wdrażanie zapewnia deklaratywne zarządzanie i aktualizacje aplikacji poprzez kontrolowanie ReplicaSetów. Ta struktura hierarchiczna gwarantuje, że aplikacje są skalowalne, odporne i łatwe w zarządzaniu. Wdrażanie abstrakcyjnie przedstawia złożoność bezpośredniego zarządzania ReplicaSetami i podami, oferując potężny sposób obsługi aktualizacji i skalowania aplikacji.
Szczegóły konfiguracji wdrażania
Używanie YAML do konfiguracji wdrażania w Kubernetesie jest powszechną praktyką ze względu na jego czytelność i prostotę. Kubernetes obsługuje zarówno format YAML, jak i JSON dla plików konfiguracyjnych, ale YAML jest szerzej stosowany ze względu na jego przyjazną dla człowieka składnię.
YAML (YAML Ain’t Markup Language) to standard serializacji danych, który jest zarówno czytelny dla człowieka, jak i łatwy do pisania. Jest powszechnie używany do plików konfiguracyjnych i wymiany danych między językami o różnych strukturach danych. W Kubernetes YAML służy do definiowania pożądanego stanu różnych obiektów, w tym wdrażaniach, usługach, podach i innych. Kluczowe elementy pliku YAML wdrażania:
apiVersionsłuży do określenia wersji API (na przykład apps/v1) obiektu Kubernetes.kindokreśla typ obiektu Kubernetes (na przykład Deployment).metadatazawiera metadane dotyczące obiektu, takie jak jego nazwa i etykiety.spec(specyfikacja) służy do zdefiniowania pożądanego stanu obiektu Kubernetes, w tym:replicasokreśla liczbę replik podów, które mają być utrzymywane.selectorokreśla sposób identyfikacji podów zarządzanych przez wdrażanie.templatedefiniuje szablon poda, w tym metadane i specyfikacje dla podów.containerswymienia kontenery w podzie, w tym:name: nazwa konteneraimage: obraz Docker do użyciaports: porty do udostępnienia
Różnice między YAML a JSON w składni wdrażania Kubernetes są następujące:
- YAML jest bardziej czytelny dla człowieka, wykorzystując wcięcia i pary klucz-wartość bez nawiasów klamrowych lub kwadratowych.
- JSON wykorzystuje bardziej sztywną strukturę z nawiasami klamrowymi ({}) i kwadratowymi ([]), co sprawia, że jest mniej czytelny w przypadku złożonych konfiguracji.
W przypadku wdrażania Kubernetes zazwyczaj preferowany jest YAML.
Przykład wdrażania w YAML
Poniżej znajduje się przykład wdrażania Kubernetes w formacie YAML wraz ze szczegółowymi konfiguracjami dla podów i kontenerów.
apiVersion: apps/v1
kind: Deployment
metadata:
name: deployment-name
spec:
replicas: 3
selector:
matchLabels:
app: app-name
template:
metadata:
labels:
app: app-name
spec:
containers:
- name: container-name
image: image-name:1.0
ports:
- containerPort: 80
resources:
requests:
memory: "128Mi"
cpu: "250m"
limits:
memory: "256Mi"
cpu: "500m"
env:
- name: MY_ENV_VAR
value: "some-value"
volumeMounts:
- mountPath: "/path/volume"
name: volume-name
volumes:
- name: volume-name
persistentVolumeClaim:
claimName: pvc-name
Wyjaśnijmy szczegółowo każdą sekcję, aby było to bardziej zrozumiałe. Konfigurując te sekcje, można zdefiniować solidne i skalowalne wdrażanie aplikacji w Kubernetes, zapewniając, że pody i kontenery są skonfigurowane zgodnie z wymaganiami.
Kluczowe sekcje konfiguracyjne
1. Metadane
metadata:
name: deployment-name
Gdzie:
name: nazwa wdrażania
2. Spec (specyfikacja wdrażania)
spec:
replicas: 3
selector:
matchLabels:
app: app-name
Gdzie:
replicas: liczba replik podów do utrzymania
selector: określa sposób identyfikacji podów zarządzanych przez wdrażanie za pomocą etykiet
3. Szablon poda (specyfikacja poda)
template:
metadata:
labels:
app: app-name
spec:
containers:
- name: container-name
image: image-name:1.0
Gdzie: metadata: etykiety do identyfikacji podów
spec: konfiguracja podów i ich kontenerów
Konfiguracja kontenerów
W tej części można zapoznać się z sekcjami YAML w wdrażaniach służącymi do konfiguracji kontenerów.
1. Obraz kontenera
image: image-name:1.0
Gdzie:
image: obraz kontenera, który ma zostać użyty. Może zawierać tag (np. 1.0) określający wersję.
2. Porty.
ports:
- containerPort: 80
Gdzie:
containerPort: port, na którym kontener będzie nasłuchiwał ruchu
3. Żądania i wymagania zasobowe
resources:
requests:
memory: "128Mi"
cpu: "250m"
limits:
memory: "256Mi"
cpu: "500m"
Gdzie:
requests: minimalne wymagania zasobowe
limits: maksymalne zasoby, z których może korzystać kontener
4. Zmienne środowiskowe
env:
- name: MY_ENV_VAR
value: "some-value"
Gdzie:
env: definiuje zmienne środowiskowe dla kontenera
5. Montowanie woluminów
volumeMounts:
- mountPath: "/path/volume"
name: volume-name
Gdzie:
volumeMounts: określa woluminy do zamontowania wewnątrz kontenera
mountPath: ścieżka wewnątrz kontenera, w której wolumin zostanie zamontowany
Konfigurowanie woluminów
Sekcja woluminy odpowiada za konfigurację woluminów.
volumes:
- name: volume-name
persistentVolumeClaim:
claimName: pvc-name
Gdzie:
volumes: definiuje woluminy dostępne do zamontowania
name: nazwa woluminu
persistentVolumeClaim: określa PersistentVolumeClaim (PVC) do użycia dla woluminu
Konfiguracje zaawansowane
1. Testy aktywności i gotowości
livenessProbe:
httpGet:
path: /healthz
port: 8080
initialDelaySeconds: 3
periodSeconds: 3
readinessProbe:
httpGet:
path: /ready
port: 8080
initialDelaySeconds: 5
periodSeconds: 10
Gdzie:
livenessProbe: sprawdza, czy kontener jest aktywny
readinessProbe: służy do sprawdzenia, czy bieżący kontener jest gotowy do przyjmowania ruchu
2. Polecenie i argumenty
command: ["my-command"]
args: ["arg1", "arg2"]
Gdzie:
command: zastępuje domyślny punkt wejścia kontenera
args: określa argumenty polecenia
3. ConfigMaps i sekrety
envFrom:
- configMapRef:
name: my-configmap
- secretRef:
name: my-secret
Gdzie:
envFrom: importuje zmienne środowiskowe z ConfigMap lub sekretu
Strategia wdrażania Kubernetes
Istnieje wiele strategii wdrażania Kubernetes (typów) i można wybrać najbardziej efektywną dla danego scenariusza. Aplikacje biznesowe mają różne wymagania dotyczące czasu pracy i dostępności. Wybór odpowiedniej strategii pozwala uniknąć przestojów i zakłóceń w działaniu usług, a także efektywnie wykorzystywać zasoby. Poniżej przedstawiono najpopularniejsze typy wdrażania w Kubernetes.
Aktualizacje stopniowe i przywracanie poprzednich wersji
Wdrażanie z aktualizacją stopniową zakłada migrację z jednej wersji aplikacji do drugiej, nowszej, w określonej kolejności. Uruchamiany jest nowy zestaw replik (ReplicaSet) z nową wersją aplikacji. Repliki starej wersji są zamykane. W rezultacie pody starej wersji zostają zastąpione nowymi. Aktualizacja stopniowa umożliwia płynne przejście ze starych wersji na nowe, ale operacja ta wymaga pewnego czasu.
Ponowne utworzenie wdrażania
Pods, które są aktualnie uruchomione, są zamykane, a następnie tworzone ponownie z nową wersją. Ta strategia wdrażania jest powszechnie stosowana w środowiskach Kubernetes dla programistów, gdzie aktywność użytkowników nie stanowi problemu. Występuje przestój, gdy stare wdrażanie jest wyłączane, strategia ponownego utworzenia wdrażania inicjuje nowe instancje wdrażania oraz odtwarza pods i stan aplikacji.
Wdrażanie typu Blue-Green
Wdrażanie typu Blue-Green to kolejny sposób aktualizacji aplikacji w Kubernetes, ale z szybkim przejściem. Wdrażanie typu Blue-Green w Kubernetes zakłada działanie dwóch środowisk: starej (niebieskiej) wersji i nowej (zielonej) wersji. Oba są wdrażane „obok siebie” lub równolegle. Gdy nowa wersja zostanie przetestowana i potwierdzone zostanie jej prawidłowe działanie (działa zgodnie z założeniami), wówczas etykieta wersji zostaje zastąpiona poprzez aktualizację selektora usługi. Czynność ta jest wykonywana dla obiektu usługi Kubernetes, który realizuje równoważenie obciążenia w klastrze. Następnie ruch jest natychmiast przełączany na nową wersję.
Strategia wdrażania typu Blue-Green w Kubernetes pozwala administratorom na szybkie wdrażanie bez problemów spowodowanych różnicami między wersjami podczas przechodzenia między nimi. Należy pamiętać, że wykorzystanie zasobów jest wyższe, ponieważ dwa środowiska działają równolegle przez pewien czas.
Wdrażanie typu canary
Wdrażanie typu canary w Kubernetes zakłada przekierowanie tylko niewielkiej grupy użytkowników do nowej wersji aplikacji kontenerowej. Nowa wersja działa na mniejszym podzbiorze podów niż starsza wersja, która działała do tego momentu. Głównym celem wdrażania typu canary jest przetestowanie funkcji nowych wersji aplikacji w środowisku produkcyjnym. Jeśli w nowej wersji nie występują błędy, administratorzy skalują ją w górę, a poprzednia wersja jest zastępowana w odpowiedniej kolejności.
Jeśli po wdrożeniu nowej wersji dla niewielkiej grupy użytkowników coś pójdzie nie tak, administratorzy mogą przywrócić wdrażanie typu canary do starszej wersji. Zaletą jest możliwość przetestowania nowej funkcji na niewielkiej grupie użytkowników bez ryzyka negatywnego wpływu na ogólne działanie systemu.
Kubernetes – opcja „Recreate Deployment”
W przypadku skorzystania z opcji „Recreate Deployment” wszystkie pody są zamykane i zastępowane nową wersją. Strategię tę można zastosować, gdy stara i nowa wersja nie mogą działać jednocześnie. Czas przestoju zależy od czasu potrzebnego na wyłączenie starej aplikacji i uruchomienie nowej w kontenerach. Po zakończeniu stan aplikacji jest całkowicie odnowiony.
Skalowanie i zarządzanie
Skalowanie i zarządzanie wdrażaniami Kubernetes ma kluczowe znaczenie dla zapewnienia, że aplikacje kontenerowe mogą pracować przy zmiennym obciążeniu i utrzymywać wysoką dostępność. Kubernetes zapewnia solidne mechanizmy zarówno do ręcznego, jak i automatycznego skalowania, a także narzędzia do efektywnego zarządzania wdrażaniami.
Skalowanie ręczne
Skalowanie ręczne służy do ręcznego dostosowywania liczby replik (instancji) aplikacji za pomocą narzędzia wiersza poleceń kubectl .
- Skalowanie w górę:
kubectl scale deployment deployment-name --replicas=10To polecenie zwiększa liczbę replik dla my-wdrażania do 10.
- Skalowanie w dół:
kubectl scale deployment deployment-name --replicas=2To polecenie zmniejsza liczbę replik dla my-wdrażania do 2.
Horizontal Pod Autoscaler (HPA)
Horizontal Pod Autoscaler (HPA) automatycznie dostosowuje liczbę replik podów na podstawie obserwowanego wykorzystania Procesora lub innych wybranych wskaźników.
- Polecenie do utworzenia HPA to:
kubectl autoscale deployment deployment-name --cpu-percent=50 --min=2 --max=10To polecenie konfiguruje HPA dla
deployment-namew celu utrzymania wykorzystania Procesora na poziomie około 50%, przeprowadzając skalowanie w zakresie od 2 do 10 replik. - Konfiguracja HPA w formacie YAML jest bardziej zaawansowaną metodą. Przykład konfiguracji wdrażania YAML dla horyzontalnego autoskalowania wyjaśniono poniżej.
apiVersion: autoscaling/v1kind: HorizontalPodAutoscalermetadata:name: deployment-hpa-namespec:scaleTargetRef:apiVersion: apps/v1kind: Deploymentname: deployment-nameminReplicas: 2maxReplicas: 10targetCPUUtilizationPercentage: 50Zastosuj konfigurację YAML za pomocą:
ubectl apply -f hpa.yaml
Vertical Pod Autoscaler (VPA)
Vertical Pod Autoscaler (VPA) automatycznie dostosowuje żądania zasobów i limity podów, aby dopasować je do rzeczywistego wykorzystania. Konfiguracja VPA w YAML wygląda następująco:
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
name: deployment-vpa-name
spec:
targetRef:
apiVersion: "apps/v1"
kind: Deployment
name: deployment-name
updatePolicy:
updateMode: "Auto"
Aby zastosować konfigurację YAML, użyj polecenia: kubectl apply -f vpa.yaml
Najlepsze rozwiązania dotyczące wdrażania w Kubernetes
Prawidłowa konfiguracja wdrażania w Kubernetes gwarantuje sprawne i niezawodne środowisko do uruchamiania aplikacji kontenerowych. Nieprawidłowa konfiguracja lub niewłaściwa strategia zarządzania wdrażaniem może prowadzić między innymi do przestojów i utraty danych. Najlepsze rozwiązania dotyczące wdrażania w Kubernetes pomagają zapewnić, że aplikacje będą odporne, skalowalne i łatwe w utrzymaniu.
Use declarative configuration. Przechowuj konfiguracje Kubernetes w plikach podlegających kontroli wersji w formacie YAML/JSON. Ułatwia to zarządzanie zmianami i przywracanie poprzednich wersji w razie potrzeby. Użyjkubectl apply -fdo zastosowania tych konfiguracji, ponieważ umożliwia to operacje idempotentne, zapewniając zgodność stanu klastra z plikami konfiguracyjnymi.Use namespace isolation. Używaj przestrzeni nazw do logicznego oddzielenia różnych środowisk (na przykład dev, staging, production) i zespołów. Pomaga to w bardziej efektywnym zarządzaniu zasobami i uprawnieniami.Resource requests and limits. Zdefiniuj żądania i limity zasobów dla swoich podów, aby zapewnić im niezbędne zasoby i zapobiec konfliktom o zasoby.Liveness and readiness probes. Skonfiguruj sondy aktywności (liveness probes) w celu ponownego uruchamiania kontenerów w nieprawidłowym stanie oraz sondy gotowości (readiness probes) w celu kontrolowania ruchu do kontenerów.Use labels and selectorsw celu organizowania i wybierania zasobów. Etykiety mogą być używane do grupowania zasobów według aplikacji, środowiska, wersji itp.Use ConfigMaps and secrets. Przechowuj dane konfiguracyjne, które nie są wrażliwe, w ConfigMaps. Przechowuj dane wrażliwe, w tym hasła i klucze API, w Secrets.Monitor and log your environment. Wdrażaj monitorowanie przy użyciu narzędzi takich jak Grafana i Prometheus, aby sprawdzać wydajność i stan aplikacji w kontenerach. Korzystaj ze scentralizowanych rozwiązań do logowania, takich jak stos ELK (Elasticsearch, Logstash, Kibana) lub Fluentd, do gromadzenia i analizowania logów.Follow security best practices. Wdrażaj zasady bezpieczeństwa podów (Pod Security Policies), aby egzekwować standardy bezpieczeństwa w podach. Użyj zasad sieciowych dla wdrażania Kubernetes, aby kontrolować ruch między podami.Prepare for backups and disaster recovery. Wprowadź regularne tworzenie kopii zapasowych zasobów Kubernetes i danych trwałych. Zaplanuj i przetestuj strategie odzyskiwania awaryjnego, aby zapewnić szybkie przywrócenie aplikacji i usług w razie awarii.
Wnioski
Wdrażania Kubernetes odgrywają kluczową rolę w zarządzaniu cyklem życia aplikacji w klastrze Kubernetes. Zapewniają one deklaratywne podejście do definiowania pożądanego stanu aplikacji, w tym liczby replik, obrazów kontenerów oraz ustawień konfiguracyjnych. Dzięki orkiestracji zestawów replik (ReplicaSets) wdrażania (Deployments) gwarantują, że działa określona liczba podów, a także automatycznie obsługują aktualizacje i przywracanie poprzednich wersji w sposób kontrolowany i płynny. Skutkuje to zwiększoną skalowalnością, odpornością i łatwością zarządzania aplikacjami, co sprawia, że wdrażania Kubernetes są niezbędnym narzędziem do wdrażania i obsługi nowoczesnych aplikacji.
