Wdrażanie Kubernetes: kompleksowy przewodnik
Kubernetes, cieszący się dużą popularnością w społeczności 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 jest definiowane za pomocą Deploymentów Kubernetes. Niniejszy wpis na blogu omawia Deploymenty Kubernetes, ich rodzaje, strategie wdrażania oraz najlepsze rozwiązania.
Co to jest Wdrażanie w Kubernetes?
Wdrażanie w Kubernetes to obiekt zasobu, który zarządza wdrażaniem i cyklem życia konteneryzowanych aplikacji w klastrach. Zapewnia aktualizacje aplikacji, zapewniając, że wymagana liczba identycznych podów działa i jest dostępna w każdym momencie. Zapewnia także deklaratywne aktualizacje dla Podów oraz ReplicaSetów. Wdrażania są kluczową funkcją w Kubernetes, pozwalającą na automatyzację skalowania, aktualizacje przetaczające i wycofania.
Wdrażanie to obiekt Kubernetes, który określa pożądany stan dla Podów i tworzy oraz zarządza ReplicaSetami, aby ten stan został utrzymany. ReplicaSet zarządza bezpośrednio Podami, w tym ich stanem oraz liczbą. Wdrażanie określa Kubernetes, w jaki sposób modyfikować lub tworzyć instancje Podów, które przechowują kontenery z aplikacjami. Stan wdrożenia Podu jest opisany w manifeście.
Administratorzy mogą efektywnie skalać liczbę replik podów, wykonywać wdrażanie zaktualizowanego kodu aplikacji z wysokim poziomem kontroli i wycofywać się do wcześniejszych wersji wdrożeń, jeśli to konieczne. 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 przy użyciu Wdrażania ma powiązany z tym padem ReplicaSet. Z kolei ReplicaSet posiada wskaźnik do Wdrażania, które utworzyło te ReplicaSet.
Podstawy Wdrażania w Kubernetes
Wdrażania w Kubernetes zostały opracowane do wdrażania i skalowania konteneryzowanych aplikacji w klastrach. Wdrażania zapewniają deklaratywny sposób definiowania pożądanego stanu aplikacji i 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 wykorzystania oraz zasoby przydzielone do każdego poda.Declarative configuration. Wdrażania zwykle korzystają z podejścia deklaratywnego, w którym administratorzy określają stan w pliku JSON lub YAML. Podczas gdy podejście imperatywne pozwala administratorom ustalić, co zrobić bezpośrednio, podejście deklaratywne w Kubernetes pozwala administratorom zdefiniować wymagany wynik, a Kubernetes osiągnie to dzięki swoim wewnętrznym mechanizmom. Kontroler Wdrażania Kubernetes monitoruje zdrowie węzłów i podów. Jeśli wystąpią zmiany w czasie rzeczywistym, takie jak awaria poda, to ten pod można zastąpić. W ten sposób Kubernetes monitoruje stan klastra w czasie rzeczywistym i dostosowuje się w celu osiągnięcia pożądanego stanu.ReplicaSet. Wdrażanie zarządza ReplicaSet. ReplicaSet tworzy i usuwa pody w miarę potrzeby, aby utrzymać wymaganą liczbę replik. To podejście pozwala Kubernetesowi zapewnić, że określone repliki podów działają w dowolnym momencie.Rolling updates. Wdrażania obsługują aktualizacje stopniowe, które pozwalają na aktualizowanie aplikacji bez przestoju. Kubernetes stopniowo zastępuje stare pode nowymi, co pomaga zapewnić, że konteneryzowana aplikacja pozostaje w stanie dostępnym podczas procesu aktualizacji wdrażania.Rollback. Jeśli coś pójdzie nie tak podczas aktualizacji w Kubernetes, można cofnąć do poprzedniej wersji wdrożenia, przywracając aplikację do znanego, dobrego stanu.
Deklaratywna konfiguracja
W Kubernetes deklaratywne podejście oznacza określenie pożądanego stanu systemu, a Kubernetes podejmuje niezbędne działania w celu osiągnięcia i utrzymania tego stanu. Opisujesz cel końcowy za pomocą plików konfiguracyjnych (zwykle napisanych w formacie YAML lub JSON), a Kubernetes nieustannie działa nad tym, aby rzeczywisty stan pokrywał się z pożądanym stanem.
Deklaratywne podejście jest generalnie preferowane w Kubernetes, ponieważ może zachować spójność pożądanego stanu, ułatwiać automatyzację i wspierać lepszą współpracę oraz kontrolę wersji. Podejście imperatywne może być użyteczne do szybkich, tymczasowych zadań, ale jest mniej odpowiednie do zarządzania bardziej skomplikowanymi, długoterminowymi wdrożeniami aplikacji.
Jak działają razem wdrażania, pody i ReplicaSet
W Kubernetes wdrażania, pody i ReplicaSet są ze sobą blisko powiązanymi komponentami, które wspólnie zarządzają wdrażaniem, skalowaniem i cyklem życia aplikacji. Ważne jest, aby zrozumieć związek między nimi i wiedzieć, jak razem działają w Kubernetes, aby prawidłowo skonfigurować system.
-
Podjest najprostszym i najmniejszym obiektem w klastrze Kubernetes i reprezentuje pojedynczą instancję działającego procesu. Pod może zawierać jeden lub więcej kontenerów, które dzielą te same woluminy magazynu i przestrzeń nazw sieci. Pody są przeznaczone do efemerycznego charakteru, ponieważ mogą być tworzone i usuwane w zależności od potrzeb, aby osiągnąć pożądany stan określony przez wyższe obiekty, takie jak wdrażania. -
ReplicaSetzapewnia, że określona liczba identycznych podów działa w dowolnym momencie. Zarządza tworzeniem i usuwaniem Podów, aby utrzymać pożądaną liczbę replik. Każdy Zbiór Replik używa selektorów etykiet do identyfikacji i zarządzania Podami pod swoją kontrolą, zapewniając, że prawidłowe Pody są utrzymywane. Mimo że można bezpośrednio tworzyć i zarządzać Zbiorami Replik, zwykle są one zarządzane przez Wdrażania, które zapewniają dodatkowe funkcje. - A
Deploymentto wyżej poziomowy obiekt Kubernetes, który zarządza Zbiorami Replik i zapewnia deklaratywne aktualizacje aplikacji. Wdrażenia pozwalają administratorom definiować potrzebny stan aplikacji i inne ustawienia, jak wyjaśniono powyżej.
Kiedy tworzysz lub aktualizujesz Wdrażanie, automatycznie tworzy nowy Zbiór Replik do zarządzania Podami zgodnie z określonymi specyfikacjami. Za każdym razem, gdy aktualizujesz Wdrażanie, tworzy się nowy Zbiór Replik do obsługi nowej wersji Podów, podczas gdy stary Zbiór Replik pozostaje do czasu, aż nowe Pody zostaną pomyślnie wprowadzone. To zapewnia, że aktualizacje są wprowadzane w kontrolowany sposób, utrzymując dostępność aplikacji.
Wdrażanie zarządza cyklem życia Podów pośrednio poprzez swoje Zbiory Replik. Definiując pożądany stan we Wdrażaniu, określasz charakterystyki i liczbę Podów, które chcesz uruchomić. Wdrażanie następnie zapewnia ten stan przez zarządzanie odpowiednimi Zbiorami Replik, które z kolei zarządzają Podami.
Tak więc Pody są jednostkami wykonawczymi uruchamiającymi kontenery, Zbiory Replik mają na celu zapewnienie potrzebnej liczby uruchomionych Podów, a Wdrażania zapewniają deklaratywne zarządzanie i aktualizacje aplikacji poprzez kontrolę Zbiorów Replik. Taka hierarchiczna struktura zapewnia, że twoje aplikacje są skalowalne, odporne i łatwe do zarządzania. Wdrażania abstrakcyjne komplikacje bezpośredniego zarządzania Zbiorami Replik i Podami, oferując potężny sposób na obsługę aktualizacji aplikacji i skalowania.
Szczegóły Konfiguracji Wdrażania
Używanie YAML do konfiguracji Wdrażania w Kubernetes jest powszechną praktyką ze względu na jego czytelność i prostotę. Kubernetes wspiera zarówno formaty YAML, jak i JSON do plików konfiguracyjnych, ale YAML jest szerzej używany ze względu na swoją przyjazną dla ludzi składnię.
YAML (YAML Ain’t Markup Language) to standard serializacji danych, który jest zarówno czytelny dla ludzi, jak i łatwy do pisania. Jest powszechnie używany do plików konfiguracyjnych i wymiany danych między językami z różnymi strukturami danych. W Kubernetes, YAML jest używany do definiowania pożądanego stanu różnych obiektów, w tym Wdrażań, Usług, Podów i więcej. Kluczowe komponenty pliku Wdrażania YAML:
apiVersionjest używany do określenia wersji API (na przykład, apps/v1) obiektu Kubernetes.kindokreśla typ obiektu Kubernetes (na przykład, Wdrażanie).metadatazawiera metadane o obiekcie, takie jak jego nazwa i etykiety.spec(specyfikacja) jest używana do zdefiniowania pożądanego stanu obiektu Kubernetes, w tym:replicasokreśla liczbę replik podów do utrzymania.selectorokreśla, jak identyfikować pody zarządzane przez Wdrażanie.templatedefiniuje szablon poda, w tym metadane i specyfikacje dla podów.containerswymienia kontenery w pody, w tym:name: nazwa konteneraimage: używany obraz Dockeraports: porty do wystawienia
Różnice między YAML a JSON dla składni konfiguracji Wdrażania Kubernetes:
- YAML jest bardziej czytelny dla człowieka, wykorzystując wcięcia i pary klucz-wartość bez nawiasów klamrowych lub kwadratowych.
- JSON używa bardziej rygorystycznej struktury z nawiasami klamrowymi ({}) i kwadratowymi ([]), przez co jest mniej czytelny w przypadku złożonych konfiguracji.
Zazwyczaj preferuje się użycie YAML dla Wdrażań Kubernetes.
Przykład Wdrażania YAML
Poniżej znajduje się przykład wdrożenia Kubernetes w formacie YAML z 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 każdą sekcję szczegółowo, aby była bardziej przejrzysta. Konfigurując te sekcje, możesz zdefiniować solidne i skalowalne wdrożenie aplikacji w Kubernetes, zapewniając, że twoje pody i kontenery są skonfigurowane zgodnie z twoimi 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, jak identyfikować pody zarządzane przez wdrażanie przy użyciu etykiet
3. Szablon Podów (specyfikacja Podów)
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 dla podów oraz ich kontenerów
Konfiguracja kontenerów
W tej części można zobaczyć sekcje YAML wdrożeń, aby skonfigurować kontenery.
1. Obraz kontenera
image: image-name:1.0
Gdzie:
image: obraz kontenera do użycia. Może zawierać znacznik (np. 1.0) do określenia wersji.
2. Porty.
ports:
- containerPort: 80
Gdzie:
containerPort: port, na którym kontener będzie nasłuchiwał ruchu
3. Żądania zasobów oraz limity
resources:
requests:
memory: "128Mi"
cpu: "250m"
limits:
memory: "256Mi"
cpu: "500m"
Gdzie:
requests: minimalne zasoby wymagane
limits: maksymalne zasoby, które kontener może wykorzystać
4. Zmienne środowiskowe
env:
- name: MY_ENV_VAR
value: "some-value"
Gdzie:
env: definiuje zmienne środowiskowe dla kontenera
5. Mocowania 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, gdzie wolumin zostanie zamontowany
Konfiguracja woluminów
Sekcja woluminów 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
Zaawansowane konfiguracje
1. Proby liveness oraz readiness
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 żywy
readinessProbe: używane do sprawdzania, czy obecny kontener jest gotowy do akceptowania ruchu
2. Komenda i argumenty
command: ["my-command"]
args: ["arg1", "arg2"]
Gdzie:
command: zastępuje domyślny punkt wejścia do kontenera
args: określa argumenty do komendy
3. ConfigMapy oraz sekrety
envFrom:
- configMapRef:
name: my-configmap
- secretRef:
name: my-secret
Gdzie:
envFrom: importuje zmienne środowiskowe z ConfigMap lub sekretu
Strategia Wdrażania Kubernetes
W Kubernetes dostępne są różne strategie wdrażania (typy), i można wybrać najefektywniejszą dla bieżącej sytuacji. Aplikacje biznesowe mają różne wymagania dotyczące czasu pracy i dostępności. Wybór odpowiedniej strategii pozwala uniknąć przestojów oraz zakłóceń w działaniu serwisu, a także efektywnie wykorzystywać zasoby. Poniżej można zobaczyć najczęściej spotykane typy wdrożeń Kubernetes.
Aktualizacje krokowe oraz wycofania
Wdrożenie aktualizacji krokowej przewiduje migrację z jednej wersji aplikacji do innej, nowszej wersji w zdefiniowanej kolejności. Uruchamiany jest nowy ReplicaSet z nową wersją aplikacji. Repliki starej wersji są zakończone. W rezultacie, pody ze starą wersją są zastępowane nowymi. Aktualizacja stopniowa umożliwia płynne przejście od starych wersji do nowych, lecz operacja wymaga pewnego czasu, aby się zakończyć.
Odtwórz wdrożenie
Pody, które są obecnie uruchomione, są zakończone, a następnie odtwarzane z nową wersją. Ta strategia wdrażania jest często stosowana w środowiskach Kubernetes dla deweloperów, gdzie aktywność użytkowników nie jest problemem. Istnieje przestój, gdy stare wdrożenie jest zamykane, strategia odtwarzania uruchamia nowe instancje wdrożeń i odtwarza pody oraz stan aplikacji.
Wdrożenie Blue-Green
Wdrożenie Blue-Green jest innym sposobem aktualizacji aplikacji w Kubernetes z szybką zmianą. Kubernetesowe wdrożenie Blue-Green zakłada uruchamianie dwóch środowisk: starej (blue) wersji i nowej (green) wersji. Oba są wdrażane „obok siebie” lub równolegle. Po przetestowaniu nowej wersji i potwierdzeniu jej poprawnego działania (działa zgodnie z założeniami), etykieta wersji jest zastępowana przez aktualizację selektora usługi. Działanie to jest wykonywane dla obiektu Usługi Kubernetes, który realizuje równoważenie obciążenia w klastrze. Po tym, ruch jest natychmiast przekierowywany do nowej wersji.
Strategia wdrożenia Blue-Green w Kubernetes pozwala administratorom na szybkie przeprowadzanie wdrożeń bez problemów wynikających z różnych wersji przy przejściu pomiędzy nimi. Należy pamiętać, że wykorzystanie zasobów jest większe, ponieważ dwa środowiska działają równolegle przez pewien okres czasu.
Kanarkowe wdrożenia
Kanarkowe wdrożenie Kubernetes zakłada przekierowanie jedynie małej grupy użytkowników do nowej wersji aplikacji konteneryzowanej. Nowa wersja działa na mniejszym podzbiorze podów niż starsza wersja, która była uruchomiona do tego czasu. Głównym celem wdrożeń kanarkowych jest przetestowanie funkcji nowych wersji aplikacji w środowisku produkcyjnym. Jeśli w nowej wersji nie ma błędów, administratorzy skalują nową wersję, a poprzednia wersja jest zastępowana w odpowiednim porządku.
Jeśli coś pójdzie nie tak po wdrożeniu nowej wersji dla małej grupy użytkowników, administratorzy mogą wycofać kanarkowe wdrożenia do starszej wersji. Zaletą jest możliwość przetestowania nowej funkcji na małej grupie użytkowników bez ryzyka negatywnych skutków dla ogólnych działań systemu.
Recreate Deployment Kubernetes
Podczas korzystania z Recreate Deployment, wszystkie pody są wyłączane i zastępowane nową wersją. Strategia ta może być stosowana, gdy stara i nowa wersja nie mogą działać równocześnie. Przestój zależy od czasu potrzebnego na zamknięcie 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żaniem Kubernetes są kluczowe, aby zapewnić, że twoje aplikacje kontenerowe mogą obsługiwać różne obciążenia i utrzymywać wysoką dostępność. Kubernetes oferuje solidne mechanizmy zarówno do ręcznego, jak i automatycznego skalowania oraz narzędzia do efektywnego zarządzania wdrażaniem.
Ręczne Skalowanie
Ręczne skalowanie jest używane 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 mojego wdrożenia do 10.
- Skalowanie w dół:
kubectl scale deployment deployment-name --replicas=2To polecenie zmniejsza liczbę replik dla mojego wdrożenia do 2.
Autoskalowanie Podów Poziomych (HPA)
Autoskalowanie Podów Poziomych (HPA) automatycznie dostosowuje liczbę replik podów na podstawie zaobserwowanego wykorzystania Procesora lub innych wybranych metryk.
- Polecenie do utworzenia HPA to:
kubectl autoscale deployment deployment-name --cpu-percent=50 --min=2 --max=10To polecenie ustawia HPA dla
deployment-nameaby utrzymać wykorzystanie Procesora na poziomie około 50%, skalując między 2 a 10 replikami. - Konfiguracja HPA w YAML jest bardziej zaawansowanym sposobem. Poniżej wyjaśniono przykład konfiguracji wdrożenia YAML dla poziomego autoskalowania.
apiVersion: autoscaling/v1kind: HorizontalPodAutoscalermetadata:name: deployment-hpa-namespec:scaleTargetRef:apiVersion: apps/v1kind: Deploymentname: deployment-nameminReplicas: 2maxReplicas: 10targetCPUUtilizationPercentage: 50Zastosuj konfigurację YAML używając polecenia:
ubectl apply -f hpa.yaml
Pionowe Autoskalowanie Podów (VPA)
Pionowe Autoskalowanie Podów (VPA) automatycznie dostosowuje żądania zasobów i limity podów do rzeczywistego zużycia. 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 praktyki dla wdrożeń Kubernetes
Prawidłowa konfiguracja wdrożeń Kubernetes zapewnia udane i niezawodne środowisko do uruchamiania aplikacji kontenerowych. Nieprawidłowa konfiguracja lub nieprawidłowa strategia zarządzania wdrożeniami mogą prowadzić do przestojów, utraty danych oraz innych problemów. Najlepsze praktyki dla wdrożeń Kubernetes pomagają zapewnić, że twoje aplikacje są odporne, skalowalne i utrzymywalne.
Use declarative configuration. Przechowuj swoje konfiguracje Kubernetes w plikach kontrolowanych wersją w formacie YAML/JSON. Ułatwia to zarządzanie zmianami i cofanie w razie potrzeby. Użyjkubectl apply -f, aby zastosować te konfiguracje, umożliwiając operacje idempotentne, zapewniając, że stan klastra odpowiada plikom konfiguracyjnym.Use namespace isolation. Używaj przestrzeni nazw, aby logicznie izolować różne środowiska (np. dev, staging, produkcja) i zespoły. Pomaga to w efektywnym zarządzaniu zasobami i uprawnieniami.Resource requests and limits. Określ żądania i limity zasobów dla twoich podów, aby mieć pewność, że mają one niezbędne zasoby i aby zapobiec konflikcie zasobów.Liveness and readiness probes. Skonfiguruj sondy liveness do restartowania niezdrowych kontenerów oraz sondy readiness do kontrolowania ruchu do kontenerów.Use labels and selectorsdo 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 nieczułe dane konfiguracyjne w ConfigMaps. Przechowuj dane wrażliwe, w tym hasła i klucze API, w Secrets.Monitor and log your environment. Implementuj monitorowanie za pomocą takich narzędzi jak Grafana i Prometheus, aby sprawdzać wydajność i stan zdrowia twoich aplikacji kontenerowych. Używaj scentralizowanych rozwiązań logowania, takich jak stos ELK (Elasticsearch, Logstash, Kibana) lub Fluentd, do zbierania i analizowania logów.Follow security best practices. Wdróż polityki bezpieczeństwa poda, aby wymusić standardy bezpieczeństwa na twoich podach. Używaj polityk sieciowych dla wdrożeń Kubernetes do kontrolowania ruchu między podami.Prepare for backups and disaster recovery. Implementuj regularne kopie zapasowe twoich zasobów Kubernetes oraz trwałych danych. Planuj i testuj strategie odzyskiwania awaryjnego, aby zapewnić szybkie przywrócenie aplikacji i usług w przypadku awarii.
Podsumowanie
Wdrożenia 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. Poprzez orkiestrację zestawów replik (ReplicaSets) wdrażanie (Deployments) gwarantuje, że działa określona liczba podów (Pods), a także automatycznie obsługuje 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żanie w Kubernetes jest niezbędnym narzędziem do wdrażania i obsługi nowoczesnych aplikacji.
