Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Wdrażanie aplikacji ASP.NET Core w Kubernetes w Google Kubernetes Engine

1. Przegląd

ASP.NET Core to nowa platforma typu open source i na wielu platformach, która umożliwia tworzenie nowoczesnych aplikacji działających w chmurze i połączonych z internetem przy użyciu języka programowania C#.

Kubernetes to projekt typu open source, który może działać w wielu różnych środowiskach, od laptopów po klastry wielowęzłowe o wysokiej dostępności, od chmur publicznych po wdrożenia lokalne, od maszyn wirtualnych po sprzęt fizyczny.

W tym module wdrożysz prostą aplikację ASP.NET Core w Kubernetes działającym w Kubernetes Engine. To ćwiczenie jest kontynuacją ćwiczenia Tworzenie i uruchamianie aplikacji ASP.NET Core za pomocą Google Cloud Shell. Zanim rozpoczniesz ten moduł, możesz najpierw wykonać tamten.

Celem tych ćwiczeń z programowania jest przekształcenie kodu (w tym przypadku prostej aplikacji Hello World ASP.NET Core) w replikowaną aplikację działającą w Kubernetes. Kod opracowany na komputerze przekształcasz w obraz kontenera Dockera, a następnie uruchamiasz go w Google Kubernetes Engine.

Aby pomóc Ci zrozumieć, jak poszczególne elementy łączą się ze sobą, przedstawiamy diagram różnych części tego laboratorium. Korzystaj z niej w trakcie wykonywania ćwiczeń. Wszystko powinno stać się jasne, gdy dotrzesz do końca (ale na razie możesz to zignorować).

Na potrzeby tego ćwiczenia użycie środowiska zarządzanego, takiego jak Kubernetes Engine (wersja Kubernetes hostowana przez Google i działająca w Compute Engine), pozwala skupić się na korzystaniu z Kubernetes zamiast na konfigurowaniu infrastruktury bazowej.

Jeśli chcesz uruchomić Kubernetes na komputerze lokalnym, np. na laptopie deweloperskim, prawdopodobnie zainteresuje Cię Minikube. Umożliwia to proste skonfigurowanie klastra Kubernetes z 1 węzłem na potrzeby programowania i testowania. Jeśli chcesz, możesz skorzystać z Minikube.

Czego się nauczysz

Jak spakować prostą aplikację ASP.NET Core jako kontener Dockera.
Jak utworzyć klaster Kubernetes w Google Kubernetes Engine (GKE).
Jak wdrożyć aplikację ASP.NET Core w podzie.
Jak zezwolić na ruch zewnętrzny do poda.
Jak skalować w górę usługę i wdrażać uaktualnienia.
Jak uruchomić graficzny panel Kubernetes.

Czego potrzebujesz

przeglądarka, np. Chrome lub Firefox;

Jak zamierzasz wykorzystać ten samouczek?

Tylko przeczytaj

Przeczytaj i wykonaj ćwiczenia

Jak oceniasz korzystanie z Google Cloud Platform?

Początkujący

Średnio zaawansowany

Zaawansowany

2. Konfiguracja i wymagania

Samodzielne konfigurowanie środowiska

Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail lub Google Workspace, musisz je utworzyć.

Nazwa projektu to wyświetlana nazwa dla uczestników tego projektu. Jest to ciąg znaków, który nie jest używany przez interfejsy API Google. Możesz ją zaktualizować w dowolnym momencie.
Identyfikator projektu musi być unikalny we wszystkich projektach Google Cloud i jest niezmienny (nie można go zmienić po ustawieniu). Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie musisz się nim przejmować. W większości przewodników programowania musisz odwoływać się do identyfikatora projektu (zwykle jest on oznaczony jako PROJECT_ID). Jeśli wygenerowany identyfikator Ci się nie podoba, możesz wygenerować inny losowy identyfikator. Możesz też spróbować utworzyć własny adres i sprawdzić, czy jest dostępny. Po tym kroku nie można go zmienić i będzie obowiązywać przez cały czas trwania projektu.
Warto wiedzieć, że istnieje trzecia wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.

Następnie musisz włączyć płatności w konsoli Cloud, aby korzystać z zasobów i interfejsów API Google Cloud. Ukończenie tego laboratorium nie powinno wiązać się z dużymi kosztami, a nawet z żadnymi. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub cały projekt. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Uruchom Cloud Shell

Z Google Cloud można korzystać zdalnie na laptopie, ale w tym ćwiczeniu użyjesz Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.

Aktywowanie Cloud Shell

W konsoli Cloud kliknij Aktywuj Cloud Shell .

Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni (poniżej linii podziału) z opisem tego środowiska. W takim przypadku kliknij Dalej, a ten ekran nie będzie się już wyświetlać. Ten wyświetlany jednorazowo ekran wygląda tak:

Uzyskanie dostępu do środowiska Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Większość zadań w tym laboratorium, a być może wszystkie, możesz wykonać w przeglądarce lub na Chromebooku.

Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu.

Aby potwierdzić, że uwierzytelnianie zostało przeprowadzone, uruchom w Cloud Shell to polecenie:

gcloud auth list

Wynik polecenia

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:

gcloud config list project

Wynik polecenia

[core]
project = <PROJECT_ID>

Jeśli nie, możesz go ustawić za pomocą tego polecenia:

gcloud config set project <PROJECT_ID>

Wynik polecenia

Updated property [core/project].

3. Tworzenie aplikacji ASP.NET Core w Cloud Shell

W wierszu poleceń Cloud Shell możesz sprawdzić, czy narzędzie wiersza poleceń dotnet jest już zainstalowane, sprawdzając jego wersję. Powinno to spowodować wyświetlenie wersji zainstalowanego narzędzia wiersza poleceń dotnet:

dotnet --version

Następnie utwórz nową szkieletową aplikację internetową ASP.NET Core.

dotnet new mvc -o HelloWorldAspNetCore

Spowoduje to utworzenie projektu i przywrócenie zależności. Wyświetli się komunikat podobny do tego poniżej.

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. Uruchamianie aplikacji ASP.NET Core

Już niedługo będzie można uruchomić aplikację. Otwórz folder aplikacji.

cd HelloWorldAspNetCore

Na koniec uruchom aplikację.

dotnet run --urls=http://localhost:8080

Aplikacja zacznie nasłuchiwać na porcie 8080.

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

Aby sprawdzić, czy aplikacja działa, kliknij przycisk podglądu w przeglądarce w prawym górnym rogu i wybierz „Podejrzyj na porcie 8080”.

Zobaczysz domyślną stronę ASP.NET Core:

Gdy sprawdzisz, czy aplikacja działa, naciśnij Ctrl+C, aby ją wyłączyć.

5. Pakowanie aplikacji ASP.NET Core jako kontenera Dockera

Następnie przygotuj aplikację do uruchomienia jako kontener. Pierwszym krokiem jest zdefiniowanie kontenera i jego zawartości.

W katalogu głównym aplikacji utwórz plik Dockerfile, aby zdefiniować obraz Dockera.

touch Dockerfile

Dodaj poniższy kod do pliku Dockerfile za pomocą ulubionego edytora (vim, nano,emacs lub edytora kodu Cloud Shell).

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

Ważną konfiguracją uwzględnioną w pliku Dockerfile jest port, na którym aplikacja nasłuchuje ruchu przychodzącego (8080). Możesz to zrobić, ustawiając zmienną środowiskową ASPNETCORE_URLS, której aplikacje ASP.NET Core używają do określania portu, na którym mają nasłuchiwać.

Zapisz to Dockerfile. Teraz utwórzmy obraz:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

Po zakończeniu tego procesu (pobieranie i wyodrębnianie wszystkich plików zajmie trochę czasu) zobaczysz, że obraz został utworzony i zapisany lokalnie:

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1

Przetestuj obraz lokalnie za pomocą tego polecenia, które uruchomi kontener Dockera lokalnie na porcie 8080 z nowo utworzonego obrazu kontenera:

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Ponownie skorzystaj z funkcji podglądu w przeglądarce Cloud Shell :

Screenshot from 2015-11-03 17:20:22.png

W nowej karcie powinna być widoczna domyślna strona ASP.NET Core.

Gdy sprawdzisz, że aplikacja działa prawidłowo lokalnie w kontenerze Dockera, możesz zatrzymać działający kontener, klikając Ctrl-> C.

Teraz, gdy obraz działa zgodnie z oczekiwaniami, możesz wypchnąć go do Google Container Registry, prywatnego repozytorium obrazów Dockera dostępnego z każdego projektu w chmurze Google (ale też spoza Google Cloud Platform) :

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Jeśli wszystko przebiegnie pomyślnie, po chwili obraz kontenera powinien pojawić się w sekcji Container Registry. W tym momencie masz już dostępny obraz Dockera w całym projekcie, do którego Kubernetes może uzyskać dostęp i którym może zarządzać, jak zobaczysz za kilka minut.

Jeśli chcesz, możesz przejrzeć obrazy kontenerów przechowywane w Google Cloud Storage, klikając ten link: https://console.cloud.google.com/storage/browser/ (pełny link powinien mieć postać https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).

6. Utwórz klaster Kubernetes

Możesz już utworzyć klaster GKE, ale najpierw przejdź do sekcji Google Kubernetes Engine w konsoli internetowej i poczekaj, aż system się zainicjuje (powinno to zająć tylko kilka sekund).

Klaster składa się z serwera Kubernetes Master API zarządzanego przez Google i zestawu węzłów roboczych. Węzły robocze to maszyny wirtualne Compute Engine.

Użyj interfejsu gcloud CLI w sesji Cloud Shell, aby utworzyć klaster. Dostosuj strefę do miejsca, w którym się znajdujesz ( lista stref). Wykonanie tych czynności zajmie kilka minut:

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

Na koniec powinien pojawić się utworzony klaster.

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

Powinien teraz działać w pełni funkcjonalny klaster Kubernetes obsługiwany przez Google Kubernetes Engine:

Czas wdrożyć własną skonteneryzowaną aplikację w klastrze Kubernetes. Od teraz będziesz używać wiersza poleceń kubectl (jest on już skonfigurowany w środowisku Cloud Shell). Pozostała część tego modułu wymaga, aby wersja klienta i serwera Kubernetes była co najmniej 1.2. kubectl version wyświetli aktualną wersję polecenia.

7. Utwórz wdrożenie

Pod Kubernetes to grupa kontenerów połączonych ze sobą na potrzeby administracji i sieci. Może zawierać jeden lub więcej kontenerów. W tym przypadku użyjesz po prostu jednego kontenera utworzonego za pomocą obrazu ASP.NET Core przechowywanego w prywatnym rejestrze kontenerów. Będzie on udostępniać treści na porcie 8080.

Utwórz plik hello-dotnet.yaml w ulubionym edytorze (vim, nano,emacs lub edytorze kodu Cloud Shell) i zdefiniuj wdrożenie Kubernetes dla poda:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

Wdróż w domyślnej przestrzeni nazw za pomocą polecenia kubectl:

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet created

Jak widzisz, udało Ci się utworzyć obiekt wdrożenia. Wdrożenia to zalecany sposób tworzenia i skalowania podów. Nowe wdrożenie zarządza tu jedną repliką poda z obrazem hello-dotnet:v1.

Aby wyświetlić właśnie utworzone wdrożenie, uruchom to polecenie:

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

Aby wyświetlić poda utworzonego przez wdrożenie, uruchom to polecenie:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-ztzrb   1/1       Running   0          57s

Teraz możesz uruchomić kilka interesujących kubectl poleceń (żadne z nich nie zmieni stanu klastra, pełna dokumentacja jest dostępna tutaj):

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

W tym momencie kontener powinien działać pod kontrolą Kubernetes, ale nadal musisz udostępnić go do użytku publicznego.

8. Zezwalaj na ruch zewnętrzny

Domyślnie pod jest dostępny tylko przez wewnętrzny adres IP w klastrze. Aby kontener hello-dotnet był dostępny spoza wirtualnej sieci Kubernetes, musisz udostępnić poda jako usługę Kubernetes.

W Cloud Shell możesz udostępnić poda w publicznym internecie za pomocą polecenia kubectl expose w połączeniu z flagą --type="LoadBalancer". Ta flaga jest wymagana do utworzenia zewnętrznie dostępnego adresu IP :

kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080

Flaga użyta w tym poleceniu określa, że będziesz używać systemu równoważenia obciążenia udostępnianego przez infrastrukturę bazową (w tym przypadku systemu równoważenia obciążenia Compute Engine). Pamiętaj, że udostępniasz wdrożenie, a nie bezpośrednio poda. Spowoduje to równoważenie obciążenia w usłudze na wszystkich podach zarządzanych przez wdrożenie (w tym przypadku tylko 1 pod, ale później dodasz więcej replik).

Węzeł główny Kubernetes tworzy system równoważenia obciążenia oraz powiązane reguły przekierowania Compute Engine, pule docelowe i reguły zapory, aby usługa była w pełni dostępna spoza Google Cloud Platform.

Aby znaleźć publicznie dostępny adres IP usługi, wystarczy wysłać żądanie kubectl, aby wyświetlić listę wszystkich usług klastra:

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Zwróć uwagę, że w przypadku Twojej usługi są wymienione 2 adresy IP, z których oba obsługują port 8080. Jeden to wewnętrzny adres IP widoczny tylko w Twojej wirtualnej sieci w chmurze, a drugi to zewnętrzny adres IP z równoważeniem obciążenia. W tym przykładzie zewnętrzny adres IP to 104.155.20.69.

Usługa powinna być teraz dostępna pod tym adresem: http://<EXTERNAL_IP>:8080

W tym momencie zyskujesz co najmniej kilka funkcji dzięki przejściu na kontenery i Kubernetes – nie musisz określać, na którym hoście ma być uruchomione Twoje obciążenie, a także korzystasz z monitorowania i ponownego uruchamiania usługi. Sprawdź, co jeszcze możesz zyskać dzięki nowej infrastrukturze Kubernetes.

9. Skalowanie usługi

Jedną z najważniejszych funkcji Kubernetes jest łatwość skalowania aplikacji. Załóżmy, że nagle potrzebujesz większej mocy obliczeniowej dla swojej aplikacji. Wystarczy, że powiesz kontrolerowi replikacji, aby zarządzał nową liczbą replik w Twoim podzie:

kubectl scale deployment hello-dotnet --replicas=4

kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         4         4            3           16m

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

Zwróć uwagę na podejście deklaratywne – zamiast uruchamiać lub zatrzymywać nowe instancje deklarujesz, ile instancji powinno działać przez cały czas. Pętle uzgadniania Kubernetes po prostu sprawdzają, czy rzeczywistość jest zgodna z Twoimi żądaniami, i w razie potrzeby podejmują odpowiednie działania.

Oto diagram podsumowujący stan klastra Kubernetes:

Możesz też bardzo łatwo skalować w dół swoją usługę. Oto jak skalować w dół z 4 podów do 2 podów.

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. Testowanie odporności

Kubernetes (a dokładniej ReplicaSet) monitoruje pody i jeśli coś jest z nimi nie tak i ulegną awarii, natychmiast tworzy nowe. Sprawdźmy, jak to działa.

Najpierw pobierz listę podów:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

Usuń jeden z podów, podając jego nazwę:

kubectl delete pod hello-dotnet-714049816-g4azy

Jeśli ponownie sprawdzisz listę podów, zobaczysz, że nowy pod jest tworzony i od razu uruchamiany:

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. Wdrażanie uaktualnienia usługi

W pewnym momencie aplikacja wdrożona w środowisku produkcyjnym będzie wymagać poprawek błędów lub dodatkowych funkcji. Zobaczmy, jak wygląda ten proces.

Najpierw zmodyfikujemy aplikację. Otwórz edytor kodu w Cloud Shell.

Wybierz kolejno HelloWorldAspNetCore > Views > Home i otwórz plik Index.cshtml, a następnie zaktualizuj jeden z komunikatów w karuzeli.

Znajdź ten wiersz:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core

Zmień go na:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

Zapisz zmiany i wróć do Cloud Shell. W folderze HelloWorldAspNetCore, skompiluj obraz Dockera:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .

i przesłać do Container Registry:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2

Kubernetes może teraz bezproblemowo zaktualizować kontroler replikacji do nowej wersji aplikacji. Aby zmienić etykietę obrazu uruchomionego kontenera, musisz edytować istniejący plik hello-dotnet deployment i zmienić obraz z gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 na gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.

W tym celu użyj polecenia kubectl edit. Spowoduje to otwarcie edytora tekstu z pełną konfiguracją wdrożenia w formacie YAML. Nie musisz teraz rozumieć całej konfiguracji YAML. Wystarczy, że wiesz, że aktualizując pole spec.template.spec.containers.image w konfiguracji, informujesz wdrożenie, aby zaktualizowało pody i zaczęło używać nowego obrazu.

kubectl edit deployment hello-dotnet

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

Po wprowadzeniu zmiany zapisz i zamknij plik (w tym celu w edytorze vi naciśnij klawisz „Esc”, a potem wpisz :wq i naciśnij klawisz „Enter”).

deployment "hello-dotnet" edited

Spowoduje to zaktualizowanie wdrożenia o nowy obraz, utworzenie nowych podów z nowym obrazem i usunięcie starych podów.

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

Użytkownicy usług nie powinni w tym czasie zauważyć żadnych przerw w działaniu. Po pewnym czasie zaczną korzystać z nowej wersji aplikacji.

Więcej informacji o aktualizacjach kroczących znajdziesz w dokumentacji Kubernetes.

Mamy nadzieję, że dzięki tym funkcjom wdrażania, skalowania i aktualizacji zgodzisz się z nami, że po skonfigurowaniu środowiska (w tym przypadku klastra GKE/Kubernetes) Kubernetes może pomóc Ci skupić się na aplikacji, a nie na zarządzaniu infrastrukturą.

12. Cloud Build

Do tej pory tworzyliśmy kontenery za pomocą zwykłych poleceń Dockera (docker build …), a następnie ręcznie przenosiliśmy obraz do Container Registry w Google Cloud Platform. Możesz też odłożyć oba kroki na stronę serwera Cloud Build, który może utworzyć i wypchnąć obraz kontenera bez lokalnej instalacji Dockera.

Najpierw włącz Cloud Build API w Menedżerze interfejsów API > Biblioteka. Wyszukaj Cloud Build i kliknij Cloud Build API:

Jeśli interfejs API nie jest jeszcze włączony, kliknij Włącz API. Na koniec powinien pojawić się włączony interfejs API:

Po włączeniu interfejsu Cloud Build API możesz uruchomić to polecenie, aby skompilować i wypchnąć obraz z usługi Container Builder:

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

Obraz jest automatycznie przechowywany w Container Registry.

13. Uruchamianie graficznego panelu Kubernetes

W najnowszych wersjach Kubernetes wprowadzono graficzny interfejs użytkownika (panel). Ten interfejs użytkownika umożliwia szybkie rozpoczęcie pracy i korzystanie z niektórych funkcji dostępnych w CLI w bardziej przystępny i łatwiejszy do odkrycia sposób interakcji z systemem.

Aby skonfigurować dostęp do panelu klastra Kubernetes, w oknie Cloud Shell wpisz te polecenia :

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

Następnie ponownie użyj funkcji podglądu Cloud Shell, aby przejść do portu 8081:

Powinno to spowodować przekierowanie do punktu końcowego interfejsu API. Może pojawić się strona „Nieautoryzowany”, ale nie musisz się tym przejmować. Aby przejść do panelu, usuń „?authuser=3” i zastąp go ciągiem „/ui”.

Korzystaj z graficznego panelu Kubernetes do wdrażania aplikacji skonteneryzowanych oraz monitorowania klastrów i zarządzania nimi.

Możesz też uzyskać dostęp do panelu z komputera deweloperskiego lub lokalnego, postępując zgodnie z instrukcjami wyświetlanymi po naciśnięciu w konsoli internetowej przycisku „Połącz” przy klastrze, który chcesz monitorować.

Gdy skończysz korzystać z panelu, możesz zatrzymać serwer proxy, naciskając Control + C. Więcej informacji o panelu Kubernetes znajdziesz w przewodniku po panelu.

14. Logowanie

Aby pobrać dzienniki kontenera działającego w Kubernetes, możesz użyć polecenia kubectl logs. Gdy używasz Google Kubernetes Engine do uruchamiania zarządzanych klastrów Kubernetes, wszystkie logi są automatycznie przekazywane i przechowywane w Google Cloud Logging. Aby wyświetlić wszystkie dane wyjściowe logów z podów, w konsoli Google Cloud otwórz Stackdriver → Logowanie → Logi:

W konsoli logowania możesz przejść do sekcji Kontener GKE, aby wyświetlić wszystkie logi zebrane z STDOUT:

Możesz stąd wyeksportować dzienniki do Google BigQuery w celu dalszej analizy lub skonfigurować alerty oparte na dziennikach. Nie będziemy tego robić podczas dzisiejszych zajęć.

15. Gratulacje!

To już koniec tych prostych ćwiczeń z programowania, które wprowadziły Cię w ASP.NET Core i Kubernetes. Zaledwie zarysowaliśmy tę technologię. Zachęcamy do dalszego poznawania jej możliwości za pomocą własnych podów, kontrolerów replikacji i usług, a także do zapoznania się z sondami żywotności (kontrolami stanu) i bezpośredniego korzystania z interfejsu Kubernetes API.

Czyszczenie danych

To wszystko. Czas na wyczyszczenie używanych zasobów (aby zaoszczędzić i być dobrym użytkownikiem chmury).

Usuń wdrożenie (co spowoduje też usunięcie działających podów) i usługę (co spowoduje też usunięcie zewnętrznego systemu równoważenia obciążenia):

Najpierw usuń usługę i wdrożenie, co spowoduje też usunięcie zewnętrznego systemu równoważenia obciążenia:

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

Następnie usuń klaster:

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

Spowoduje to usunięcie wszystkich instancji Google Compute Engine, na których działa klaster.

Na koniec usuń zasobnik pamięci rejestru Dockera, w którym znajdują się obrazy:

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Możesz też oczywiście usunąć cały projekt, ale stracisz wtedy wszystkie skonfigurowane ustawienia płatności (najpierw musisz wyłączyć płatności za projekt). Usunięcie projektu spowoduje wstrzymanie naliczania opłat dopiero po zakończeniu bieżącego cyklu rozliczeniowego.

Omówione zagadnienia

Jak spakować prostą aplikację ASP.NET Core jako kontener Dockera.
Jak utworzyć klaster Kubernetes w Google Kubernetes Engine.
Jak wdrożyć aplikację ASP.NET Core w podzie.
Jak zezwolić na ruch zewnętrzny do poda.
Jak skalować w górę usługę i wdrażać uaktualnienia.
Jak uruchomić graficzny panel Kubernetes.

Następne kroki

Więcej informacji o Kubernetes znajdziesz na stronie http://kubernetes.io/.
Dowiedz się więcej o Windows w Google Cloud Platform.
Dowiedz się więcej o .NET w Google Cloud Platform.
Dowiedz się więcej o SQL Server na Google Cloud Platform.
Dowiedz się więcej o Cloud Tools for Visual Studio.
Dowiedz się więcej o Cloud Tools for PowerShell.

Licencja

To zadanie jest licencjonowane na podstawie ogólnej licencji Creative Commons Attribution 2.0.