🥇Przygotowanie aplikacji dla Istio

Istio to wygodne narzędzie do łączenia, zabezpieczania i monitorowania aplikacji rozproszonych. Istio wykorzystuje różnorodne technologie do uruchamiania oprogramowania i zarządzania nim na dużą skalę, w tym kontenery do pakowania kodu aplikacji i zależności na potrzeby wdrożenia oraz Kubernetes do zarządzania tymi kontenerami. Dlatego, aby pracować z Istio, musisz wiedzieć, jak działa aplikacja z wieloma usługami opartymi na tych technologiach без Istio. Jeśli te narzędzia i koncepcje są już Ci znane, możesz pominąć ten samouczek i przejść od razu do sekcji Instalowanie Istio w Google Kubernetes Engine (GKE) lub instalowanie rozszerzenia Istio w GKE.

To przewodnik krok po kroku, w którym przeprowadzimy Cię przez cały proces od kodu źródłowego do kontenera GKE, aby na przykładzie przedstawić podstawowe zrozumienie tych technologii. Zobaczysz także, jak Istio wykorzystuje moc tych technologii. Zakłada się, że nie wiesz nic o kontenerach, Kubernetesie, siatkach usług ani Istio.

zadania

W tym samouczku wykonasz następujące zadania:

Nauka prostej aplikacji hello world z wieloma usługami.
Uruchom aplikację z kodu źródłowego.
Pakowanie aplikacji w pojemniki.
Tworzenie klastra Kubernetes.
Wdrażanie kontenerów w klastrze.

Zanim zaczniesz

Postępuj zgodnie z instrukcjami, aby włączyć interfejs API Kubernetes Engine:

Idź do Strona Kubernetes Engine w konsoli Google Cloud Platform.
Utwórz lub wybierz projekt.
Poczekaj, aż interfejs API i powiązane usługi zostaną włączone. To może zająć parę minut.
Upewnij się, że dla Twojego projektu Google Cloud Platform skonfigurowano rozliczenia. Dowiedz się, jak włączyć rozliczenia.

W tym samouczku możesz użyć Cloud Shell, który przygotowuje maszynę wirtualną g1-small w Google Compute Engine z systemem Linux opartym na Debianie lub komputerem z systemem Linux lub macOS.

Opcja A: Korzystanie z Cloud Shell

Korzyści z używania Cloud Shell:

Środowiska programistyczne Python 2 i Python 3 (w tym virtualenv) są w pełni skonfigurowane.
Narzędzia wiersza poleceń gcloud, doker, odrzutowiec и kubectl, z których będziemy korzystać, są już zainstalowane.
Masz kilka do wyboru edytory tekstu:
1. Edytor kodu, który otwiera się za pomocą ikony edycji u góry okna Cloud Shell.
2. Emacs, Vim lub Nano, które otwierają się z wiersza poleceń w Cloud Shell.

Używać Powłoka w chmurze:

Przejdź do konsoli GCP.
Naciśnij przycisk Aktywuj Cloud Shell (Aktywuj Cloud Shell) u góry okna konsoli GCP.

W dolnej części Konsola GCP Sesja Cloud Shell z wierszem poleceń otworzy się w nowym oknie.

Opcja B: Lokalne użycie narzędzi wiersza poleceń

Jeśli będziesz pracować na komputerze z systemem Linux lub macOS, będziesz musiał skonfigurować i zainstalować następujące komponenty:

Dostosuj Środowisko programistyczne Python 3 i Python 2.
Zainstaluj pakiet SDK chmury za pomocą narzędzia wiersza poleceń gcloud.
Zestaw kubectl - narzędzie wiersza poleceń do pracy Kubernetes.
```
gcloud components install kubectl
```
Zestaw Docker Community Edition (CE). Będziesz używać narzędzia wiersza poleceń dokerdo tworzenia obrazów kontenerów dla przykładowej aplikacji.
Zainstaluj narzędzie Kontrola wersji Gitaaby pobrać przykładową aplikację z GitHuba.

Pobierz przykładowy kod

Pobierz kod źródłowy helloserver:

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

Przejdź do przykładowego katalogu kodu:
```
cd istio-samples/sample-apps/helloserver
```

Eksplorowanie aplikacji z wieloma usługami

Przykładowa aplikacja napisana jest w języku Python i składa się z dwóch komponentów wchodzących w interakcję za pomocą REST:

serwer: prosty serwer z jednym punktem końcowym DOSTAWAĆ, /, który wypisuje na konsoli „witaj świecie”.
ładowanie: skrypt, który wysyła ruch do serwer, z konfigurowalną liczbą żądań na sekundę.

Uruchamianie aplikacji z kodu źródłowego

Aby zapoznać się z przykładową aplikacją, uruchom ją w Cloud Shell lub na swoim komputerze.
1) W katalogu istio-samples/sample-apps/helloserver uruchomić serwer:

python3 server/server.py

Podczas uruchamiania serwer wyświetla się:

INFO:root:Starting server...

2) Otwórz kolejne okno terminala, do którego chcesz wysyłać żądania serwer. Jeśli używasz Cloud Shell, kliknij ikonę dodawania, aby otworzyć kolejną sesję.
3) Wyślij zapytanie do serwer:

curl http://localhost:8080

odpowiedzi serwera:

Hello World!

4) Z katalogu, z którego pobrałeś przykładowy kod, przejdź do katalogu zawierającego ładowanie:

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

5) Utwórz następujące zmienne środowiskowe:

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

6) Biegnij virtualenv:

virtualenv --python python3 env

7) Aktywuj środowisko wirtualne:

source env/bin/activate

8) Ustal wymagania dla ładowanie:

pip3 install -r requirements.txt

9) Biegnij ładowanie:

python3 loadgen.py

Podczas uruchamiania ładowanie wyświetla mniej więcej następujący komunikat:

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

W innym oknie terminala serwer wyświetla następujące komunikaty na konsoli:

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 punktu widzenia sieci cała aplikacja działa na jednym hoście (komputerze lokalnym lub maszynie wirtualnej Cloud Shell). Dlatego możesz użyć localhostdo wysyłania próśb serwer.
10) Zatrzymać się ładowanie и serwer, Wchodzić Ctrl+c w każdym oknie terminala.
11) W oknie terminala ładowanie dezaktywuj środowisko wirtualne:

deactivate

Pakowanie aplikacji w kontenery

Aby uruchomić aplikację na GKE, należy spakować przykładową aplikację − serwer и ładowanie - w pojemniki. Kontener to sposób pakowania aplikacji w celu odizolowania jej od środowiska.

Aby spakować aplikację do kontenera, potrzebujesz Dockerfile. Dockerfile to plik tekstowy, który definiuje polecenia służące do budowania kodu źródłowego aplikacji i jego zależności Obraz Dockera. Po zbudowaniu przesyłasz obraz do rejestru kontenerów, takiego jak Docker Hub lub Rejestr kontenerów.

Przykład już ma Dockerfile dla serwer и ładowanie ze wszystkimi niezbędnymi poleceniami do zbierania obrazów. Poniżej - Dockerfile dla serwer:

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/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

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

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Add the application
COPY . .

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

Zespół Z Pythona: 3-slim jako podstawa mówi Dockerowi, aby użył najnowszej Obraz Pythona 3 jako baza.
Zespół KOPIUJ. . kopiuje pliki źródłowe do bieżącego katalogu roboczego (w naszym przypadku tylko serwer.py) do systemu plików kontenera.
PUNKT WEJŚCIA definiuje polecenie używane do uruchomienia kontenera. W naszym przypadku to polecenie jest prawie takie samo, jak to, które uruchomiłeś serwer.py z kodu źródłowego.
Zespół OŚWIADCZENIE wskazuje na to serwer oczekuje na dane przez port 8080. Ten zespół nie jest udostępnia porty. Jest to swego rodzaju dokumentacja potrzebna do otwarcia portu 8080 podczas uruchamiania kontenera.

Przygotowanie do konteneryzacji aplikacji

1) Ustaw następujące zmienne środowiskowe. Zastępować PROJEKT_ID do identyfikatora projektu GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Używanie wartości PROJEKT_ID и GCR_REPO oznaczasz obraz platformy Docker podczas jego budowania i wypychasz go do prywatnego rejestru kontenerów.

2) Ustaw domyślny projekt GCP dla narzędzia wiersza poleceń gcloud.

gcloud config set project $PROJECT_ID

3) Ustaw domyślną strefę dla narzędzia wiersza poleceń gcloud.

gcloud config set compute/zone us-central1-b

4) Upewnij się, że usługa Container Registry jest włączona w projekcie GCP.

gcloud services enable containerregistry.googleapis.com

Serwer konteneryzacji

Przejdź do katalogu, w którym znajduje się przykład serwer:

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

Złóż obraz za pomocą Dockerfile oraz zmienne środowiskowe, które zdefiniowałeś wcześniej:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parametr -t reprezentuje tag Docker. Jest to nazwa obrazu używanego podczas wdrażania kontenera.

Prześlij obraz do Container Registry:

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

Konteneryzacja modułu ładującego

1) Przejdź do katalogu, w którym znajduje się przykład ładowanie:

cd ../loadgen

2) Zbierz obraz:

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

3) Prześlij obraz do Container Registry:

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

Wyświetl listę obrazów

Przejrzyj listę obrazów w repozytorium i sprawdź, czy obrazy zostały przesłane:

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

Polecenie wyświetla nazwy nowo przesłanych obrazów:

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

Tworzenie klastra GKE.

Kontenery te można uruchomić na maszynie wirtualnej Cloud Shell lub na komputerze za pomocą polecenia uruchamianie dokera. Jednak w środowisku produkcyjnym potrzebny jest sposób na centralne organizowanie kontenerów. Na przykład potrzebujesz systemu, który gwarantuje, że kontenery będą zawsze działać, oraz sposobu na skalowanie i uruchamianie dodatkowych instancji kontenerów w przypadku wzrostu ruchu.

Aby uruchomić aplikacje kontenerowe, możesz użyć G.K.E.. GKE to platforma do orkiestracji kontenerów, która agreguje maszyny wirtualne w klaster. Każda maszyna wirtualna nazywana jest węzłem. Klastry GKE oparte są na systemie zarządzania klastrami Kubernetes typu open source. Kubernetes udostępnia mechanizmy interakcji z klastrem.

Tworzenie klastra GKE:

1) Utwórz klaster:

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

Zespół gcloud tworzy klaster istioready w projekcie GCP i określonej strefie domyślnej. Aby uruchomić Istio, zalecamy posiadanie co najmniej 4 węzłów i maszyny wirtualnej n1-standard-2.

Zespół tworzy klaster w ciągu kilku minut. Gdy klaster jest gotowy, polecenie zwraca coś takiego сообщение.

2) Podaj dane uwierzytelniające w narzędziu wiersza poleceń kubectlaby użyć go do zarządzania klastrem:

gcloud container clusters get-credentials istioready

3) Teraz możesz komunikować się z Kubernetesem za pośrednictwem kubectl. Na przykład następujące polecenie może sprawdzić stan węzłów:

kubectl get nodes

Polecenie generuje listę węzłów:

NAME                                       STATUS   ROLES    AGE    VERSION
gke-istoready-default-pool-dbeb23dc-1vg0   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Ready    <none>   100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Ready    <none>   99s    v1.13.6-gke.13

Kluczowe koncepcje Kubernetesa

Diagram przedstawia aplikację na GKE:

Zanim wdrożysz kontenery w GKE, poznaj kluczowe koncepcje Kubernetes. Jeśli chcesz dowiedzieć się więcej, na samym końcu znajdują się linki.

Węzły i klastry. W GKE węzeł jest maszyną wirtualną. Na innych platformach Kubernetes węzłem może być komputer lub maszyna wirtualna. Klaster to zbiór węzłów, które można uznać za pojedynczą jednostkę, w której wdrażana jest aplikacja kontenerowa.
Strąki. W Kubernetes kontenery działają w zasobnikach. Pod w Kubernetesie jest niepodzielną jednostką. Kapsuła zawiera jeden lub więcej pojemników. Wdrażasz kontenery serwerów i ładowanie w oddzielnych strąkach. Jeśli w zasobniku znajduje się kilka kontenerów (na przykład serwer aplikacji i Serwer proxy), kontenery są zarządzane jako pojedyncza jednostka i współdzielą zasoby podów.
Wdrożenia. W Kubernetesie wdrożenie to obiekt będący kolekcją identycznych podów. Wdrożenie uruchamia wiele replik zasobników rozproszonych w węzłach klastra. Wdrożenie automatycznie zastępuje zasobniki, które uległy awarii lub nie odpowiadają.
Usługa Kubernetesa. Podczas uruchamiania kodu aplikacji w GKE połączenie pomiędzy ładowanie и serwer. Po uruchomieniu usług na maszynie wirtualnej lub komputerze Cloud Shell wysyłałeś żądania do serwer o godz localhost: 8080. Po wdrożeniu w GKE pody są uruchamiane w dostępnych węzłach. Domyślnie nie masz kontroli nad tym, na którym węźle działa pod, więc Ty strąki brak stałych adresów IP.
Aby uzyskać adres IP dla serwer, musisz zdefiniować abstrakcję sieci na górze zasobników. To jest to Usługa Kubernetesa. Usługa Kubernetes zapewnia trwały punkt końcowy dla zestawu zasobników. Jest kilka rodzaje usług. serwer używa Load Balancer, który zapewnia zewnętrzny adres IP do kontaktu serwer spoza klastra.
Kubernetes ma także wbudowany system DNS, który przypisuje nazwy DNS (np. helloserver.default.cluster.local) usługi. Dzięki temu pody w klastrze komunikują się z innymi podami w klastrze pod stałym adresem. Nazwy DNS nie można używać poza klastrem, na przykład w Cloud Shell lub na komputerze.

Manifest Kubernetesa

Uruchamiając aplikację ze źródła, użyłeś polecenia imperatywnego python3

serwer.py

Tryb rozkazujący implikuje czasownik: „zrób to”.

Kubernetes używa model deklaratywny. Oznacza to, że nie mówimy Kubernetesowi dokładnie, co ma zrobić, a raczej opisujemy pożądany stan. Na przykład Kubernetes uruchamia i zatrzymuje pody w razie potrzeby, aby upewnić się, że rzeczywisty stan systemu odpowiada żądanemu stanowi.

Pożądany stan wskazujesz w manifestach lub plikach YAM. Plik YAML zawiera specyfikacje jednego lub większej liczby obiektów Kubernetes.

Przykład zawiera plik YAML dla serwer и ładowanie. Każdy plik YAML określa pożądany stan obiektu wdrożenia i usługi Kubernetes.

serwer.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

uprzejmy wskazuje typ obiektu.
metadane.nazwa określa nazwę wdrożenia.
Pierwsze pole specyfikacja zawiera opis pożądanego stanu.
spec.repliki wskazuje żądaną liczbę kapsułek.
Rubryka szablon specyfikacji definiuje szablon poda. W specyfikacji poda znajduje się pole obraz, który określa nazwę obrazu, który należy wyodrębnić z rejestru kontenerów.

Usługę definiuje się następująco:

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

Load Balancer: Klienci wysyłają żądania na adres IP modułu równoważenia obciążenia, który ma stały adres IP i jest dostępny spoza klastra.
port docelowy: jak pamiętacie, zespół EKSPOZYCJA 8080 в Dockerfile nie zapewnił portów. Podajesz port 8080abyś mógł skontaktować się z kontenerem serwer poza klastrem. W naszym przypadku hellosvc.default.cluster.local:80 (krótkie imię: cześć vc) odpowiada portowi 8080 Adresy IP podów helloserver.
Port: Jest to numer portu, na który inne usługi w klastrze będą wysyłać żądania.

ładowanie.yaml

Obiekt wdrożenia do ładowanie.yaml wygląda jak serwer.yaml. Różnica polega na tym, że obiekt wdrożenia zawiera sekcję env. Definiuje zmienne środowiskowe, które są potrzebne ładowanie i które zainstalowałeś podczas uruchamiania aplikacji ze źródła.

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

czas ładowanie nie akceptuje przychodzących żądań dla tego pola rodzaj wskazane IP klastra. Ten typ zapewnia trwały adres IP, z którego mogą korzystać usługi w klastrze, ale ten adres IP nie jest udostępniany klientom zewnętrznym.

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

Wdrażanie kontenerów w GKE

1) Przejdź do katalogu, w którym znajduje się przykład serwer:

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

2) Otwórz serwer.yaml w edytorze tekstu.
3) Zmień nazwę w polu obraz na nazwę obrazu Dockera.

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

Zastępować PROJEKT_ID do identyfikatora projektu GCP.
4) Zapisz i zamknij serwer.yaml.
5) Wdróż plik YAML w Kubernetes:

kubectl apply -f server.yaml

Po pomyślnym zakończeniu polecenie generuje następujący kod:

deployment.apps/helloserver created
service/hellosvc created

6) Przejdź do katalogu, w którym ładowanie:

cd ../loadgen

7) Otwórz ładowanie.yaml w edytorze tekstu.
8) Zmień nazwę w polu obraz na nazwę obrazu Dockera.

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

Zastępować PROJEKT_ID do identyfikatora projektu GCP.
9) Zapisz i zamknij ładowanie.yaml, zamknij edytor tekstu.
10) Wdróż plik YAML w Kubernetes:

kubectl apply -f loadgen.yaml

Po pomyślnym zakończeniu polecenie generuje następujący kod:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Sprawdź stan zasobników:

kubectl get pods

Polecenie pokazuje status:

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

12) Wyodrębnij dzienniki aplikacji z kapsuły ładowanie. Zastąpić POD_ID do identyfikatora z poprzedniej odpowiedzi.

kubectl logs loadgenerator-POD_ID

13) Uzyskaj zewnętrzne adresy IP cześć vc:

kubectl get service

Odpowiedź na polecenie wygląda mniej więcej tak:

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      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

14) Wyślij zapytanie do cześć vc: zastępować ZEWNĘTRZNY_IP na zewnętrzny adres IP cześć vc.

curl http://EXTERNAL_IP

Weźmy Istio

Masz już wdrożoną aplikację w GKE. ładowanie może używać Kubernetes DNS (cześćvc:80), do którego chcesz wysyłać prośby serweri możesz wysyłać prośby do serwer przez zewnętrzny adres IP. Chociaż Kubernetes ma wiele funkcji, brakuje pewnych informacji na temat usług:

W jaki sposób usługi wchodzą ze sobą w interakcję? Jakie są powiązania pomiędzy usługami? Jak przepływa ruch pomiędzy usługami? Czy jesteś tego świadomy? ładowanie wysyła prośby do serwer, ale wyobraź sobie, że nic nie wiesz o aplikacji. Aby odpowiedzieć na te pytania, spójrzmy na listę działających podów w GKE.
Metryka. Jak długo serwer odpowiada na przychodzące żądanie? Ile żądań na sekundę odbiera serwer? Czy wyświetla komunikaty o błędach?
Informacja bezpieczeństwa. Ruch pomiędzy ładowanie и serwer po prostu przechodzi HTTP lub przez mTLS?

Istio odpowiada na wszystkie te pytania. Aby to zrobić, Istio umieszcza serwer proxy przyczepki Wysłannik w każdym pojemniku. Serwer proxy Envoy przechwytuje cały ruch przychodzący i wychodzący do kontenerów aplikacji. To znaczy, że serwer и ładowanie odbieraj za pośrednictwem bocznego serwera proxy Envoy i cały ruch z ładowanie к serwer przechodzi przez serwer proxy Envoy.

Połączenia pomiędzy serwerami proxy Envoy tworzą siatkę usług. Architektura Service Mesh zapewnia warstwę kontroli nad Kubernetesem.

Ponieważ serwery proxy Envoy działają we własnych kontenerach, Istio można zainstalować na klastrze GKE niemal bez zmian w kodzie aplikacji. Ale wykonałeś trochę pracy, aby przygotować aplikację do zarządzania przez Istio:

Usługi dla wszystkich kontenerów. Do wdrożeń serwer и ładowanie powiązany z usługą Kubernetes. Nawet ładowanie, który nie odbiera przychodzących żądań, istnieje usługa.
Porty w usługach muszą mieć nazwy. Chociaż porty usług można pozostawić w GKE bez nazw, Istio wymaga ich określenia nazwa portu zgodnie z jego protokołem. W pliku YAML port dla serwer nazywane httpponieważ serwer używa protokołu HTTP. Jeśli usługa używany gRPC, nazwałbyś port grpc.
Wdrożenia są oznaczone. Dlatego możesz korzystać z funkcji zarządzania ruchem Istio, takich jak dzielenie ruchu między wersjami tej samej usługi.

Instalowanie Istio

Istnieją dwa sposoby instalacji Istio. Móc włącz Istio na rozszerzeniu GKE lub zainstaluj wersję Istio o otwartym kodzie źródłowym na klastrze. Dzięki Istio w GKE możesz łatwo zarządzać instalacjami i aktualizacjami Istio przez cały cykl życia klastra GKE. Jeśli chcesz mieć najnowszą wersję Istio lub większą kontrolę nad konfiguracją panelu sterowania Istio, zainstaluj wersję open source zamiast rozszerzenia Istio on GKE. Aby zdecydować o podejściu, przeczytaj artykuł Czy potrzebuję Istio w GKE?.

Wybierz opcję, przejrzyj odpowiedni przewodnik i postępuj zgodnie z instrukcjami, aby zainstalować Istio w klastrze. Jeśli chcesz używać Istio z nowo wdrożoną aplikacją, umożliwić implementację przyczepki bocznej dla przestrzeni nazw domyślnym.

Czyszczenie

Aby uniknąć obciążenia konta Google Cloud Platform za zasoby użyte w tym samouczku, usuń klaster kontenerów po zainstalowaniu Istio i uruchomieniu przykładowej aplikacji. Spowoduje to usunięcie wszystkich zasobów klastra, takich jak instancje obliczeniowe, dyski i zasoby sieciowe.

Co dalej?

Poznaj następujące technologie:
Poznaj następujące narzędzia:
Poznaj koncepcje Kubernetes:
1. Klastry
2. Węzły
3. Strąki
4. Usługi
5. Rozlokowanie

Źródło: www.habr.com

Przygotowanie aplikacji dla Istio