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. Ten moduł opiera się na module 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 ułatwić Ci zrozumienie, 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 laboratorium użycie zarządzanego środowiska, takiego jak Kubernetes Engine (wersja Kubernetes hostowana przez Google i działająca w Compute Engine), pozwala skupić się na korzystaniu z Kubernetes, a nie 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, aby przejść ten samouczek.
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 pode.
- 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
Jak zamierzasz korzystać z tego samouczka?
Jak oceniasz korzystanie z Google Cloud Platform?
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 ani Google Workspace, musisz je utworzyć.
- Nazwa projektu to wyświetlana nazwa 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 ćwiczeń z 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ć własnej nazwy i sprawdzić, czy jest dostępna. Po tym kroku nie można go zmienić i będzie obowiązywać przez cały czas trwania projektu. - Warto wiedzieć, że istnieje też trzecia wartość, czyli numer projektu, z której korzystają 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 bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.
Uruchamianie Cloud Shell
Z Google Cloud można korzystać zdalnie na laptopie, ale w tym module praktycznym będziesz używać 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 (część strony widoczna po przewinięciu) 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 module, 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ę. Powinna się wyświetlić wersja 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
Nasza aplikacja jest już prawie gotowa do uruchomienia. Otwórz folder aplikacji.
cd HelloWorldAspNetCore
Na koniec uruchom aplikację.
dotnet run --urls=http://localhost:8080
Aplikacja zaczyna 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ę internetową ASP.NET Core:
Gdy sprawdzisz, czy aplikacja działa, naciśnij Ctrl+C, aby ją wyłączyć.
5. Spakuj aplikację ASP.NET Core jako kontener 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 w ulubionym edytorze (vim, nano,emacs lub edytorze 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ą zawartą 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 .
Gdy proces się zakończy (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 :
W nowej karcie powinna być widoczna domyślna strona internetowa 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 przesłać go do Google Container Registry, czyli 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ć, co 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 być teraz dostępny 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). W pozostałej części tego modułu wymagane jest, 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ć 1 kontener lub większą ich liczbę. 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 jest dobry moment, aby zapoznać się z kilkoma interesującymi poleceniami kubectl (ż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 adresu IP dostępnego z zewnątrz :
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, że usługa będzie równoważyć obciążenie we 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, po prostu poproś kubectl o wyświetlenie listy 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, które 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 aplikacji. Wystarczy, że poinformujesz kontroler replikacji, aby zarządzał nową liczbą replik w przypadku poda:
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, od razu tworzy nowe. Sprawdźmy, jak to działa.
Najpierw pobierz listę zasobnikó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 lub dodatkowych funkcji. Zobaczmy, jak wygląda ten proces.
Najpierw zmodyfikujemy aplikację. Otwórz edytor kodu w Cloud Shell.
W sekcji HelloWorldAspNetCore > Views > Home kliknij Index.cshtml i zaktualizuj jedną z wiadomości 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 HelloWorldAspNetCore, skompiluj obraz Dockera:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
i przekazać 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.
Aby to zrobić, 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 używało 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
W tym czasie użytkownicy usług nie powinni 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ę, że po skonfigurowaniu środowiska (w tym przypadku klastra GKE lub 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óra może tworzyć i przekazywać obraz kontenera bez konieczności 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ć przejście 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ż otworzyć panel na komputerze deweloperskim lub lokalnym, 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
Możesz użyć polecenia kubectl logs, aby pobrać dzienniki kontenera działającego w Kubernetes. 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, aby przeprowadzić dalszą analizę, 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 rozważenia 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ż 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 pode.
- 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.