🥇Příprava aplikace pro Istio

Istio je užitečný nástroj pro propojení, zabezpečení a monitorování distribuovaných aplikací. V Istio se používají různé technologie pro škálovatelné nasazení softwaru a jeho správu, včetně kontejnerů pro zabalení kódu aplikace a závislostí pro nasazení a Kubernetes pro správu těchto kontejnerů. Proto musíte znát, jak aplikace s více službami založené na těchto technologiích funguje. bez Istio. Pokud vám tyto nástroje a pojmy již jsou známé, klidně toto průvodce přeskočte a přejděte rovnou k části. Instalace Istio na Google Kubernetes Engine (GKE) nebo instalace rozšíření Istio na GKE.

Toto je krok za krokem průvodce, kde projdeme celý proces od zdrojového kódu po kontejner na GKE, abyste získali základní představu o těchto technologiích na příkladu. Také uvidíte, jak Istio využívá možnosti těchto technologií. Předpokládá se, že neznáte nic o kontejnerech, Kubernetes, service mesh nebo Istio.

Úkoly

V tomto průvodci provedete následující úkoly:

Prozkoumání jednoduché aplikace hello world s několika službami.
Spuštění aplikace ze zdrojového kódu.
Zabalení aplikace do kontejnerů.
Vytvoření Kubernetes clusteru.
Nasazení kontejnerů do clusteru.

Než začnete

Postupujte podle pokynů k aktivaci API Kubernetes Engine:

Přejděte na stránku Kubernetes Engine v konzole Google Cloud Platform.
Vytvořte nebo vyberte projekt.
Počkejte, až se API a související služby aktivují. Může to trvat několik minut.
Ujistěte se, že je pro projekt Google Cloud Platform nastaveno fakturace. Zjistěte, jak aktivovat fakturaci.

V tomto průvodci můžete použít Cloud Shell, který připraví virtuální stroj g1-small na Google Compute Engine s Linuxem na bázi Debian, nebo počítač s Linuxem nebo macOS.

Varianta A: použití Cloud Shell

Výhody používání Cloud Shell:

Vývojové prostředí Python 2 a Python 3 (včetně virtualenv) jsou plně nakonfigurovaná.
Nástroje příkazového řádku gcloud, docker, git a kubectl, které budeme používat, jsou již nainstalovány.
Můžete si vybrat z několika textových editorů:
1. Editor kódu, který se otevírá ikonou úprav v horní části okna Cloud Shell.
2. Emacs, Vim nebo Nano, které se otevírají z příkazového řádku v Cloud Shell.

Pro použití Cloud Shell:

Přejděte do konzole GCP.
Stiskněte tlačítko Aktivujte Cloud Shell (Aktivovat Cloud Shell) v horní části okna konzole GCP.

V dolní části konzole GCP se otevře nové okno se sezením Cloud Shell s příkazovým řádkem.

Varianta B: použití nástrojů příkazového řádku lokálně

Pokud budete pracovat na počítači s Linuxem nebo macOS, musíte nastavit a nainstalovat následující komponenty:

Nastavte prostředí pro vývoj Python 3 a Python 2.
Nainstalujte Cloud SDK s nástrojem příkazového řádku gcloud.
Nainstalujte kubectl — nástroj příkazového řádku pro práci s Kubernetes.
```
gcloud components install kubectl
```
Nainstalujte Docker Community Edition (CE). Budete používat nástroj příkazového řádku docker, abyste vytvářeli obrazy kontejnerů pro příklad aplikace.
Nainstalujte nástroj verze kontrolního systému Git, abyste získali příklad aplikace z GitHubu.

Stahování příkladu kódu

Stáhněte zdrojový kód helloserver:

git clone https://github.com/GoogleCloudPlatform/istio-samples

Přejděte do adresáře příkladu kódu:
```
cd istio-samples/sample-apps/helloserver
```

Prozkoumání aplikace s více službami

Příklad aplikace je napsán v Pythonu a skládá se ze dvou komponent, které spolu komunikují přes REST:

server: jednoduchý server s jednou koncovou adresou GET, /, který vypisuje „hello world“ na konzoli.
loadgen: skript, který posílá provoz na server, s nastavitelným počtem požadavků za sekundu.

Spuštění aplikace ze zdrojového kódu

Abyste prozkoumali příklad aplikace, spusťte jej v Cloud Shell nebo na počítači.
1) V adresáři istio-samples/sample-apps/helloserver spusťte server:

python3 server/server.py

Při spuštění server se zobrazí následující:

INFO:root:Starting server...

2) Otevřete další okno terminálu, abyste mohli posílat požadavky na server. Pokud používáte Cloud Shell, klikněte na ikonu plus, aby se otevřela další sezení.
3) Pošlete požadavek na server:

curl http://localhost:8080

server odpovídá:

Hello World!

4) Z adresáře, kam jste stáhli příklad kódu, přejděte do adresáře, který obsahuje loadgen:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/loadgen

5) Vytvořte následující proměnné prostředí:

export SERVER_ADDR=http://localhost:8080
export REQUESTS_PER_SECOND=5

6) Spusťte virtualenv:

virtualenv --python python3 env

7) Aktivujte virtuální prostředí:

source env/bin/activate

8) Nainstalujte požadavky pro loadgen:

pip3 install -r requirements.txt

9) Spusťte loadgen:

python3 loadgen.py

Při spuštění loadgen vytiskne přibližně následující zprávu:

Starting loadgen: 2019-05-20 10:44:12.448415
5 request(s) complete to http://localhost:8080

V jiném okně terminálu server vytiskne na konzoli přibližně následující zprávy:

127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

Z pohledu sítě, všechny aplikace běží na jednom hostiteli (místním počítači nebo virtuálním stroji Cloud Shell). Proto můžete použít localhost, abyste odeslali požadavky na server.
10) Chcete-li zastavit loadgen a server, zadejte Ctrl-c v každém okně terminálu.
11) V okně terminálu loadgen deaktivujte virtuální prostředí:

deactivate

Balení aplikace do kontejnerů

Chcete-li spustit aplikaci na GKE, musíte zabalit ukázkovou aplikaci — server a loadgen — v kontejnery. Kontejner je způsob, jak zabalit aplikaci, aby se izolovala od prostředí.

K zabalení aplikace do kontejneru potřebujete Dockerfile. Dockerfile — to je textový soubor, kde jsou definovány příkazy pro sestavení zdrojového kódu aplikace a jejích závislostí do obrazu Docker. Po sestavení nahráváte obraz do registru kontejnerů, například Docker Hub nebo Container Registry.

Ukázka již obsahuje Dockerfile pro server a loadgen všechny potřebné příkazy pro sestavení obrazů. Níže je Dockerfile pro server:

FROM python:3-slim as base
FROM base as builder
RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        g++ 
    && rm -rf /var/lib/apt/lists/*

# Povolit nebufferované protokolování
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        wget

WORKDIR /helloserver

# Získejte balíčky ze stavitele
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Přidejte aplikaci
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

Tým FROM python:3-slim as base povoluje Docker používat poslední obraz Python 3 jako základní.
Tým COPY. . kopíruje zdrojové soubory do aktuální pracovní složky (v našem případě pouze server.py) do souborového systému kontejneru.
ENTRYPOINT definuje příkaz, který se používá k spuštění kontejneru. V našem případě tento příkaz téměř odpovídá tomu, který jste použili pro spuštění server.py ze zdrojového kódu.
Tým EXPOSE naznačuje, že server očekává data přes port 8080. Tento příkaz nezajišťuje porty. Je to něco jako dokumentace, která je potřebná k otevření portupři spuštění kontejneru. 8080 Příprava na kontejnerizaci aplikace

1) Nastavte následující proměnné prostředí. Nahraďte

PROJECT_ID PROJECT_ID identifikátorem svého projektu GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

S pomocí hodnot PROJECT_ID a GCR_REPO označujete obraz Docker, když ho sestavujete a nahráváte do soukromého Container Registry.

2) Nastavte projekt GCP jako výchozí pro nástroj příkazové řádky gcloud.

gcloud config set project $PROJECT_ID

3) Nastavte výchozí zónu pro nástroj příkazové řádky gcloud.

gcloud config set compute/zone us-central1-b

4) Ujistěte se, že služba Container Registry je povolena v projektu GCP.

gcloud services enable containerregistry.googleapis.com

Containerizace serveru

Přejděte do adresáře, kde se nachází příklad server:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

Vytvořte obraz pomocí Dockerfile a proměnných prostředí, které jste definovali dříve:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parameter -t představuje tag Dockeru. To je název obrazu, který používáte při nasazování kontejneru.

Odešlete obraz do Container Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Containerizace loadgen

1) Přejděte do adresáře, kde se nachází příklad loadgen:

cd ../loadgen

2) Vytvořte obraz:

docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

3) Odešlete obraz do Container Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

Zobrazení seznamu obrazů

Prohlédněte si seznam obrazů v repozitáři a ujistěte se, že obrazy byly odeslány:

gcloud container images list --repository gcr.io/$PROJECT_ID/preparing-istio

Příkaz vrací názvy právě odeslaných obrazů:

NAME
gcr.io/PROJECT_ID/preparing-istio/helloserver
gcr.io/PROJECT_ID/preparing-istio/loadgen

Vytvoření klastru GKE.

Tyto kontejnery by mohly být spuštěny na virtuálním stroji Cloud Shell nebo na počítači pomocí příkazu docker run. Ale v produkčním prostředí je potřeba způsob, jak centrálně orchestraci kontejnerů. Například je potřeba systém, který zajišťuje, že kontejnery vždy běží, a je potřeba způsob, jak škálovat a spouštět další instance kontejnerů, pokud vzroste provoz.

Pro spuštění kontejnerových aplikací lze použít GKE. GKE je platforma pro orchestraci kontejnerů, která spojuje virtuální stroje do klastru. Každý virtuální stroj se nazývá uzel. Klastrové GKE jsou založeny na open-source systému správy klastrů Kubernetes. Kubernetes poskytuje mechanizmy pro interakci s klastrem.

Vytvoření klastru GKE:

1) Vytvořte klastr:

gcloud container clusters create istioready 
  --cluster-version latest 
  --machine-type=n1-standard-2 
  --num-nodes 4

Tým gcloud vytváří klastr istioready v projektu GCP a ve výchozí zóně, kterou jste uvedli. Pro spuštění Istio doporučujeme mít alespoň 4 uzly a virtuální stroj n1-standard-2.

Příkaz vytváří klastr několik minut. Jakmile je klastr připraven, příkaz vrací něco podobného prohlášení.

2) Udejte přihlašovací údaje v nástroji příkazového řádku kubectl, abyste mohli spravovat klastr:

gcloud container clusters get-credentials istioready

3) Nyní můžete komunikovat s Kubernetes přes kubectl. Například tímto příkazem můžete zjistit stav uzlů:

kubectl get nodes

Příkaz vrací seznam uzlů:

NÁZEV                                       STAV   ROLE    VĚK    VERZE
gke-istoready-default-pool-dbeb23dc-1vg0   Připraveno       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Připraveno       100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Připraveno       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Připraveno       99s    v1.13.6-gke.13

Klíčové pojmy Kubernetes

Na schématu je znázorněna aplikace na GKE:

Než nasadíte kontejnery do GKE, seznamte se s klíčovými pojmy Kubernetes. Na konci jsou odkazy, pokud se chcete dozvědět více.

Uzly a clustery. V GKE je uzel virtuální stroj. Na jiných platformách může být uzlem počítač nebo virtuální stroj. Cluster je soubor uzlů, které lze považovat za celek a kde nasazujete kontejnerizovanou aplikaci.
Pod’y. V Kubernetes se kontejnery spouštějí v podech. Pod v Kubernetes je nedělitelná jednotka. Pod obsahuje jeden nebo více kontejnerů. Nasazujete kontejnery server a loadgen v oddělených podech. Když v podu běží několik kontejnerů (například server aplikace a proxy server), jsou kontejnery spravovány jako jeden objekt a společně využívají zdroje podu.
Nasazení. V Kubernetes je nasazení objektem, který představuje sadu identických podů. Nasazení spouští několik replik podů, rozložených po uzlech clusteru. Nasazení automaticky nahrazuje pody, které selhaly nebo neodpovídají.
Služba Kubernetes. Při spuštění kódu aplikace v GKE se mění spojení mezi loadgen a server. Když jste spustili služby na virtuálním stroji Cloud Shell nebo na počítači, odesílali jste požadavky na server na adrese localhost:8080. Po nasazení v GKE běží pody na dostupných uzlech. Ve výchozím nastavení nemůžete řídit, na kterém uzlu běží pod, takže pod’y neexistují trvalé IP adresy.
Aby bylo možné získat IP adresu pro server, je třeba definovat abstrakci sítě nad pody. To je služba Kubernetes. Služba Kubernetes poskytuje trvalý koncový bod pro sadu podů. Existuje několik typů služeb. server používá LoadBalancer, které poskytují externí IP adresu pro komunikaci s server zvenčí clustera.
Navíc v Kubernetes existuje integrovaný systém DNS, který přiděluje názvy DNS (například helloserver.default.cluster.local) službám. Díky tomu se pod’y uvnitř clusteru propojují s jinými pod’y v clusteru pod trvalou adresou. Jméno DNS nelze používat mimo cluster, například v Cloud Shell nebo na počítači.

Manifesty Kubernetes

Když jste spustili aplikaci ze zdrojového kódu, použili jste imperativní příkaz python3

server.py

Imperativnost znamená sloveso: „udělej to“.

Kubernetes používá deklarační model. To znamená, že neříkáme Kubernetes, co přesně má dělat, ale popisujeme požadovaný stav. Například Kubernetes spouští a zastavuje pod’y podle potřeby, aby skutečný stav systému odpovídal požadovanému.

Požadovaný stav určujete v manifestech, nebo souborech YAML. Soubor YAML obsahuje specifikace pro jeden nebo více objektů Kubernetes.

V příkladu je obsažen soubor YAML pro server a loadgen. Každý soubor YAML určuje požadovaný stav objektu nasazení a služby Kubernetes.

server.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  selector:
    matchLabels:
      app: helloserver
  replicas: 1
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always

kind určuje typ objektu.
metadata.name určuje jméno nasazení.
První pole spec obsahuje popis požadovaného stavu.
spec.replicas určuje požadovaný počet pod’ů.
Sekce spec.template definuje šablonu pod’u. Ve specifikaci pod’ů je pole obrázek, kde je uvedeno jméno obrazu, který má být stažen z Container Registry.

Služba se definuje následovně:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  type: LoadBalancer
  selector:
    app: helloserver
  ports:
  - name: http
    port: 80
    targetPort: 8080

LoadBalancer: klienti posílají požadavky na IP adresu vyrovnávače zátěže, který má trvalou IP adresu a který je dostupný zvenčí clusteru.
targetPort: jak si pamatujete, příkaz EXPOSE 8080 v Dockerfile neposkytoval porty. Poskytujete port 8080, aby bylo možné navázat spojení s kontejnerem server mimo cluster. V našem případě hellosvc.default.cluster.local:80 (krátké jméno: hellosvc) odpovídá portu 8080 IP adresy podu helloserver.
port: to je číslo portu, na který ostatní služby v clusteru budou posílat požadavky.

loadgen.yaml

Objekt nasazení v loadgen.yaml vypadá jako server.yaml. Rozdíl spočívá v tom, že objekt nasazení obsahuje sekci env. Určuje proměnné prostředí, které jsou potřeba loadgen a které jste nastavili při spuštění aplikace ze zdrojového kódu.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  selector:
    matchLabels:
      app: loadgenerator
  replicas: 1
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        env:
        - name: SERVER_ADDR
          value: "http://hellosvc:80/"
        - name: REQUESTS_PER_SECOND
          value: "10"
        resources:
          requests:
            cpu: 300m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi

Jednou loadgen nepřijímá příchozí požadavky, pro pole type uvedeno ClusterIP. Tento typ poskytuje trvalou IP adresu, kterou mohou služby v klastru používat, ale tato IP adresa není poskytována externím klientům.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  type: ClusterIP
  selector:
    app: loadgenerator
  ports:
  - name: http
    port: 80
    targetPort: 8080

Nasazení kontejnerů v GKE

1) Přejděte do adresáře, kde se nachází příklad server:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

2) Otevřete server.yaml v textovém editoru.
3) Změňte název v poli obrázek na název vašeho Docker obrazu.

image: gcr.io/PROJECT_ID/preparing-istio/helloserver:v0.0.1

Nahraďte PROJECT_ID na identifikátor vašeho projektu GCP.
4) Uložte a zavřete server.yaml.
5) Nasazení YAML souboru do Kubernetes:

kubectl apply -f server.yaml

Po úspěšném dokončení příkaz vydá následující kód:

deployment.apps/helloserver created
service/hellosvc created

6) Přejděte do adresáře, kde se nachází loadgen:

cd ../loadgen

7) Otevřete loadgen.yaml v textovém editoru.
8) Změňte název v poli obrázek na název vašeho Docker obrazu.

image: gcr.io/PROJECT_ID/preparing-istio/loadgenv0.0.1

Nahraďte PROJECT_ID na identifikátor vašeho projektu GCP.
9) Uložte a zavřete loadgen.yaml, zavřete textový editor.
10) Nasazení YAML souboru do Kubernetes:

kubectl apply -f loadgen.yaml

Po úspěšném dokončení příkaz vydá následující kód:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Zkontrolujte stav podů:

kubectl get pods

Příkaz ukazuje stav:

NAME                             READY   STATUS    RESTARTS   AGE
helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s

12) Získejte záznamy aplikace z podu loadgen. Nahraďte POD_ID na identifikátor z předchozí odpovědi.

kubectl logs loadgenerator-POD_ID

13) Získejte externí IP adresy hellosvc:

kubectl get service

Odpověď příkazu vypadá přibližně takto:

NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
kubernetes   ClusterIP      10.81.0.1                443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155             80/TCP         4m52s

14) Odeslat požadavek na hellosvc: změňte EXTERNAL_IP na externí IP adresu hellosvc.

curl http://EXTERNAL_IP

Jdeme na Istio

Máte již aplikaci nasazenou v GKE. loadgen může použít Kubernetes DNS (hellosvc:80), abyste mohli odesílat požadavky na server, a můžete odesílat požadavky na server přes externí IP adresu. I když Kubernetes má mnoho funkcí, některé informace o službách chybí:

Jak služby spolupracují? Jaké jsou vztahy mezi službami? Jak probíhá provoz mezi službami? Víte, že loadgen odesílá požadavky na server, ale představte si, že o aplikaci nic nevíte. Abychom mohli odpovědět na tyto otázky, podíváme se na seznam spuštěných podů v GKE.
Metriky. Jak dlouho server odpovídá na příchozí požadavek? Kolik požadavků za sekundu přichází na server? Vydává chybová hlášení?
Informace o zabezpečení. Provoz mezi loadgen a server probíhá jednoduše pomocí HTTP nebo přes mTLS?

Na všechny tyto otázky odpovídá Istio. Proto Istio umisťuje sidecar proxy Envoy do každého podu. Proxy Envoy zachycuje veškerý příchozí a odchozí provoz k aplikačním kontejnerům. To znamená, že server a loadgen obdrží prostřednictvím sidecar proxy Envoy a veškerý provoz od loadgen k server prochází přes proxy Envoy.

Spojení mezi proxy Envoy tvoří service mesh. Architektura service mesh poskytuje úroveň řízení nad Kubernetes.

Jelikož proxy Envoy běží v jejich kontejnerech, lze Istio nainstalovat na vrcholu clustera GKE, téměř bez změny kódu aplikace. Ale udělali jste nějakou práci, abyste připravili aplikaci na správu pomocí Istio:

Služby pro všechny kontejnery. K nasazením server a loadgen je připojena jedna služba Kubernetes. I loadgen, ke které neprocházejí žádné příchozí požadavky, má službu.
Porty ve službách musí mít názvy. Ačkoliv v GKE lze porty služeb ponechat bez názvu, Istio vyžaduje, aby byl uveden název portu v souladu s jeho protokolem. V YAML souboru je port pro server nazývá http, protože server používá protokol HTTP. Kdyby service používal gRPC, pojmenovali byste port grpc.
Nasazení jsou označena. Proto můžete využít funkce řízení provozu Istio, například rozdělením provozu mezi verzemi jedné služby.

Instalace Istio

Istio lze nainstalovat dvěma způsoby. Můžete zapnout rozšíření Istio on GKE nebo nainstalovat open-source verzi Istio na cluster. S Istio on GKE je snadné spravovat instalaci a aktualizaci Istio v rámci životního cyklu clustera GKE. Pokud potřebujete nejnovější verzi Istio nebo větší kontrolu nad konfigurací ovládacího panelu Istio, nainstalujte open-source verzi namísto rozšíření Istio on GKE. Pro rozhodnutí o přístupu si přečtěte článek Potřebuji Istio on GKE?.

Vyberte možnost, prostudujte příslušného průvodce a postupujte podle pokynů k instalaci Istio na cluster. Pokud chcete použít Istio s právě nasazenou aplikací, aktivujte nasazení sidecar. prostor názvů default.

Vymazat

Aby se poplatky za zdroje, které jste použili v tomto průvodci, neodečítaly z účtu Google Cloud Platform, odstraňte kontejnerový cluster, jakmile nainstalujete Istio a vyzkoušíte příklad aplikace. Tím se odstraní všechny prostředky clusteru, jako jsou výpočetní instance, disky a síťové zdroje.

Co dál?

Seznamte se s následujícími technologiemi:
1. Docker
2. Kontejnery
3. Container Registry
4. Kubernetes
5. GKE
6. Service mesh
7. Istio
Seznamte se s následujícími nástroji:
Seznamte se s pojmy Kubernetes:
1. Klastery
2. Uzly
3. Pod’y
4. Služby
5. Nasazení

Zdroj: habr.com