1. Omówienie
ASP.NET Core to nowa, wieloplatformowa platforma open source, która służy do tworzenia nowoczesnych aplikacji działających w chmurze i połączonych z internetem za pomocą języka programowania C#.
Kubernetes to projekt open source, który może działać w wielu różnych środowiskach, od laptopów po klastry z wieloma węzłami o wysokiej dostępności, od chmur publicznych po wdrożenia lokalne, od maszyn wirtualnych po usługi Bare Metal.
W tym module wdrożysz w Kubernetes prostą aplikację ASP.NET Core w Kubernetes Engine. To ćwiczenie w Codelabs opiera się na kompilacji i uruchamianiu aplikacji ASP.NET Core za pomocą Google Cloud Shell. Warto go ukończyć przed rozpoczęciem tego modułu.
Celem tego ćwiczenia w Codelabs jest przekształcenie kodu (prosta aplikacja Hello World ASP.NET Core) w zreplikowaną aplikację działającą w Kubernetes. W tym celu bierzesz napisany na komputerze kod, zmieniasz go w obraz kontenera Dockera, a następnie uruchamiasz ten obraz w Google Kubernetes Engine.
Oto schemat poszczególnych części tego ćwiczenia z programowania, które pomogą Ci zrozumieć, jak elementy się ze sobą łączą. Wykorzystaj go jako pomoc podczas wykonywania ćwiczeń z programowania. Zanim dojdziesz do końca, wszystko powinno mieć sens (ale na razie możesz to pominąć).
Na potrzeby tego ćwiczenia z programowania korzystanie z zarządzanego środowiska takiego jak Kubernetes Engine (hostowana przez Google wersja Kubernetes działająca w Compute Engine) pozwala skupić się bardziej na korzystaniu z Kubernetes, a nie na konfiguracji bazowej infrastruktury.
Jeśli zamierzasz uruchomić Kubernetes na swoim komputerze lokalnym (np. na laptopie programistycznym), prawdopodobnie warto zainteresować się usługą Minikube. Umożliwia to prostą konfigurację klastra Kubernetes z 1 węzłem na potrzeby programowania i testowania. Jeśli chcesz, możesz wykonać to ćwiczenia z programowania za pomocą 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ć usługę i wdrożyć uaktualnienie.
- Jak uruchomić graficzny panel Kubernetes.
Czego potrzebujesz
Jak wykorzystasz ten samouczek?
Jak oceniasz swoje doświadczenia z Google Cloud Platform?
2. Konfiguracja i wymagania
Samodzielne konfigurowanie środowiska
- Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub wykorzystaj już istniejący. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.
- Nazwa projektu jest wyświetlaną nazwą uczestników tego projektu. To ciąg znaków, który nie jest używany przez interfejsy API Google. W każdej chwili możesz ją zmienić.
- Identyfikator projektu musi być unikalny we wszystkich projektach Google Cloud i nie można go zmienić (nie można go zmienić po ustawieniu). Cloud Console automatycznie wygeneruje unikalny ciąg znaków. zwykle nieważne, co ona jest. W większości ćwiczeń z programowania konieczne jest odwołanie się do identyfikatora projektu (zwykle nazywa się on
PROJECT_ID). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować kolejny losowy. Możesz też spróbować własnych sił i sprawdzić, czy jest dostępna. Potem nie będzie można go zmienić. Pozostanie ono przez czas trwania projektu. - Dostępna jest trzecia wartość, numer projektu, z którego korzystają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.
- Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Cloud/interfejsów API. Ukończenie tego ćwiczenia z programowania nie powinno kosztować zbyt wiele. Aby wyłączyć zasoby, aby nie naliczać 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 o wartości 300 USD.
Uruchamianie Cloud Shell
Google Cloud można obsługiwać zdalnie z laptopa, ale w ramach tego ćwiczenia z programowania wykorzystasz Google Cloud Shell – środowisko wiersza poleceń działające w chmurze.
Aktywowanie Cloud Shell
- W konsoli Cloud kliknij Aktywuj Cloud Shell
.
Jeśli dopiero zaczynasz korzystać z Cloud Shell, wyświetli się ekran pośredni (w części strony widocznej po przewinięciu) z opisem tej funkcji. W takim przypadku kliknij Dalej (nie zobaczysz go więcej). Tak wygląda ten jednorazowy ekran:
Uzyskanie dostępu do Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna ma wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Większość czynności z tego ćwiczenia z programowania można wykonać w przeglądarce lub na Chromebooku.
Po nawiązaniu połączenia z Cloud Shell powinno pojawić się informacja, że użytkownik jest już uwierzytelniony i że projekt jest już ustawiony na identyfikator Twojego projektu.
- Uruchom to polecenie w Cloud Shell, aby potwierdzić, że jesteś uwierzytelniony:
gcloud auth list
Dane wyjściowe polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Uruchom to polecenie w Cloud Shell, aby sprawdzić, czy polecenie gcloud zna Twój projekt:
gcloud config list project
Dane wyjściowe polecenia
[core] project = <PROJECT_ID>
Jeśli tak nie jest, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Dane wyjściowe polecenia
Updated property [core/project].
3. Tworzenie aplikacji ASP.NET Core w Cloud Shell
Aby sprawdzić, czy narzędzie wiersza poleceń dotnet jest zainstalowane w wierszu poleceń Cloud Shell, sprawdź jego wersję. Powinna wyświetlić się wersja zainstalowanego narzędzia wiersza poleceń dotnet:
dotnet --version
Następnie utwórz nowy szkielet aplikacji internetowej ASP.NET Core.
dotnet new mvc -o HelloWorldAspNetCore
Powinno to utworzyć projekt i przywrócić jego 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
Jesteśmy prawie gotowi do uruchomienia naszej aplikacji. Przejdź do folderu 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 jest uruchomiona, w prawym górnym rogu kliknij przycisk podglądu w przeglądarce i wybierz „Podejrzyj na porcie 8080”.
Zobaczysz domyślną stronę internetową ASP.NET Core:
Po sprawdzeniu, 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 kontenera. Pierwszym krokiem jest zdefiniowanie kontenera i jego zawartości.
W katalogu podstawowym aplikacji utwórz Dockerfile, aby zdefiniować obraz Dockera.
touch Dockerfile
Dodaj do Dockerfile ten kod za pomocą swojego 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"]
Jedną z ważnych konfiguracji w pliku Dockerfile jest port, na którym aplikacja nasłuchuje ruchu przychodzącego (8080). Można to osiągnąć przez ustawienie zmiennej środowiskowej ASPNETCORE_URLS, której aplikacje ASP.NET Core używają do określania portu nasłuchującego.
Zapisz element Dockerfile. Teraz załóżmy ten obraz:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Po zakończeniu tego procesu (pobranie i wyodrębnienie wszystkich danych może trochę potrwać), 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 spowoduje uruchomienie kontenera Dockera lokalnie na porcie 8080 z nowo utworzonego obrazu kontenera:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Jeszcze raz skorzystaj z funkcji podglądu w przeglądarce CloudShell :
W nowej karcie powinna wyświetlić się domyślna strona internetowa ASP.NET Core.
Gdy upewnisz się, że aplikacja działa prawidłowo lokalnie w kontenerze Dockera, możesz zatrzymać uruchomiony kontener do Ctrl-> C.
Gdy obraz działa zgodnie z oczekiwaniami, możesz go przekazać do Google Container Registry – prywatnego repozytorium obrazów Dockera, które jest dostępne z każdego projektu Google Cloud (ale także spoza Google Cloud Platform) :
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Jeśli wszystko pójdzie dobrze, po chwili powinien być widoczny obraz kontenera wymieniony w sekcji Container Registry. W tej chwili dostępny jest obraz Dockera obejmujący cały projekt, do którego Kubernetes może uzyskać dostęp i którym może administrować – co będzie widoczne za kilka minut.
Jeśli chcesz przeglądać obrazy kontenerów przechowywane w Google Cloud Storage, kliknij ten link: https://console.cloud.google.com/storage/browser/ (pełny link powinien wyglądać tak: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).
6. Tworzenie klastra Kubernetes
Teraz możesz utworzyć klaster GKE, ale wcześniej przejdź do sekcji Google Kubernetes Engine w konsoli internetowej i poczekaj na zainicjowanie systemu (powinno to zająć tylko kilka sekund).
Klaster składa się z serwera Kubernetes master API zarządzanego przez Google oraz zbioru węzłów roboczych. Węzły robocze to maszyny wirtualne Compute Engine.
Utwórzmy klaster za pomocą interfejsu wiersza poleceń gcloud z sesji CloudShell. Dostosuj strefę do miejsca w pobliżu ( lista stref). Może to potrwać kilka minut:
gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b
Na koniec zobaczysz 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
Teraz w pełni działający klaster Kubernetes obsługiwany przez Google Kubernetes Engine:
Czas wdrożyć własną aplikację skonteneryzowaną w klastrze Kubernetes. Od teraz będziesz używać wiersza poleceń kubectl (jest on już skonfigurowany w Twoim środowisku Cloud Shell). Pozostała część tego ćwiczenia w Codelabs wymaga, aby klient i serwer Kubernetes były w wersji 1.2 lub nowszej. kubectl version wyświetli bieżącą wersję polecenia.
7. Utwórz wdrożenie
Pod Kubernetes to grupa kontenerów połączonych ze sobą na potrzeby administrowania i sieci. Może zawierać jeden lub wiele kontenerów. Tutaj wykorzystasz jeden kontener utworzony z obrazem ASP.NET Core przechowywanym w Twoim prywatnym rejestrze kontenerów. Treści będą wyświetlane na porcie 8080.
Utwórz plik hello-dotnet.yaml w swoim 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ą: kubectl:
kubectl apply -f hello-dotnet.yaml
deployment.apps/hello-dotnet created
Jak widać, obiekt deployment został utworzony. Wdrożenia to zalecany sposób tworzenia i skalowania podów. W tym przypadku nowe wdrożenie zarządza 1 repliką podów obsługującą obraz hello-dotnet:v1.
Aby wyświetlić nowo utworzone wdrożenie, po prostu uruchom polecenie:
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-dotnet 1 1 1 1 37s
Aby wyświetlić pod utworzony 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 na zapoznanie 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 światu zewnętrznemu.
8. Zezwalaj na ruch zewnętrzny
Domyślnie pod jest dostępny tylko przez jego wewnętrzny adres IP w klastrze. Aby udostępnić kontener hello-dotnet spoza sieci wirtualnej Kubernetes, musisz udostępnić pod jako usługę Kubernetes.
W Cloud Shell możesz udostępnić poda w internecie publicznym za pomocą polecenia kubectl expose w połączeniu z flagą --type="LoadBalancer". Ta flaga jest wymagana do utworzenia dostępnego zewnętrznie adresu IP :
kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080
Flaga użyta w tym poleceniu wskazuje, że będziesz używać systemu równoważenia obciążenia udostępnianego przez bazową infrastrukturę (w tym przypadku system równoważenia obciążenia Compute Engine). Pamiętaj, że udostępniasz wdrożenie, a nie bezpośrednio pod. Spowoduje to równoważenie obciążenia ruchu generowanego przez powstałą usługę we wszystkich podach zarządzanych przez wdrożenie (w tym przypadku tylko 1 pod, ale później dodasz więcej replik).
Master Kubernetes tworzy system równoważenia obciążenia i powiązane reguły przekierowania Compute Engine, pule docelowe i reguły zapory sieciowej, aby zapewnić pełną dostępność usługi spoza Google Cloud Platform.
Aby znaleźć dostępny publicznie adres IP usługi, wyślij żądanie kubectl do 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ę na 2 adresy IP dotyczące Twojej usługi, które obsługują port 8080. Pierwszym z nich jest wewnętrzny adres IP, który jest widoczny tylko w sieci wirtualnej w chmurze. a drugi to zewnętrzny adres IP z zrównoważonym obciążeniem. W tym przykładzie zewnętrzny adres IP to 104.155.20.69.
Usługa powinna być teraz dostępna po wpisaniu w przeglądarce tego adresu: http://<EXTERNAL_IP>:8080
Masz już co najmniej kilka funkcji związanych z przejściem na kontenery i Kubernetes – nie musisz określać, na którym hoście masz uruchomić swoje zadanie. Zyskujesz też możliwość monitorowania i ponownego uruchamiania usługi. Zobaczmy, co jeszcze możesz zyskać dzięki nowej infrastrukturze Kubernetes.
9. Skaluj usługi
Jedną z zaawansowanych funkcji platformy Kubernetes jest łatwość skalowania aplikacji. Załóżmy, że nagle potrzebujesz większej pojemności na aplikację. możesz po prostu zlecić kontrolerowi replikacji zarządzanie nową liczbą replik Twojego 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, musisz zadeklarować, ile instancji powinno być działających w danym momencie. Pętle uzgadniania Kubernetes po prostu dbają o to, aby rzeczywistość była zgodna z żądaniami i w razie potrzeby podjęto odpowiednie działania.
Oto diagram z podsumowaniem stanu klastra Kubernetes:
Usługę można także bardzo łatwo skalować w dół. Aby zmniejszyć liczbę podów z 4 do 2 w dół:
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 nim nie tak i nie działa, od razu tworzy nowy. 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
Gdy jeszcze raz spojrzysz na listę podów, zobaczysz, że nowy pod jest tworzony i uruchamiany od razu:
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
Aplikacja wdrożona w wersji produkcyjnej będzie czasami wymagała poprawek błędów lub dodatkowych funkcji. Zobaczmy, jak wygląda ten proces.
Najpierw zmodyfikujmy aplikację. Otwórz edytor kodu z Cloud Shell.
Przejdź do Index.cshtml pod adresem HelloWorldAspNetCore > Views > Home i zaktualizuj jeden z wiadomości karuzeli.
Znajdź ten wiersz:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core
I zmień go na taki:
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. Wewnątrz HelloWorldAspNetCore,utwórz obraz Dockera:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
Potem wypchnij go do Container Registry:
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2
Teraz Kubernetes może sprawnie zaktualizować kontroler replikacji do nowej wersji aplikacji. Aby zmienić etykietę obrazu aktywnego kontenera, zmodyfikuj istniejący hello-dotnet deployment i zmień obraz z gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 na gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.
Użyjesz do tego polecenia kubectl edit. Otworzy się edytor tekstu, w którym wyświetlana jest pełna konfiguracja pliku yaml wdrożenia. Nie musisz teraz rozumieć pełnej konfiguracji yaml. Zamiast tego pamiętaj, że aktualizując pole spec.template.spec.containers.image w konfiguracji, informujesz wdrożenie, że ma zaktualizować pody tak, aby używały 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 zmian zapisz i zamknij plik (korzysta z vi – naciśnij „Esc”, a następnie wpisz :wq i naciśnij klawisz „Enter”).
deployment "hello-dotnet" edited
Spowoduje to zaktualizowanie wdrożenia o nowy obraz, co spowoduje 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 międzyczasie użytkownicy nie powinni w tym czasie mieć żadnych przerw w dostępie do usług. Po chwili zaczną uzyskiwać dostęp do nowej wersji aplikacji.
Więcej informacji o aktualizacjach kroczących znajdziesz w dokumentacji Kubernetes.
Mamy nadzieję, że dzięki tym funkcjom wdrożenia, skalowania i aktualizacji zgodzisz się, że po skonfigurowaniu środowiska (w tym miejscu klastra GKE/Kubernetes) Kubernetes pomoże 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 (kompilacja Dockera ...), a następnie ręcznie przenieśliśmy obraz do Container Registry w Google Cloud Platform. Możesz też odroczyć oba kroki do Cloud Build po stronie serwera, która kompiluje i wypycha obraz kontenera bez konieczności lokalnej instalacji Dockera.
Najpierw włącz Cloud Build API w sekcji Menedżer interfejsów API > Biblioteka. Wyszukaj Cloud Build, a potem kliknij Cloud Build API:
Kliknij opcję Włącz interfejs API, jeśli nie jest jeszcze włączona. Na koniec interfejs API powinien być włączony w ten sposób:
Po włączeniu interfejsu Cloud Build API możesz uruchomić to polecenie, aby skompilować i przekazać wszystko to z usługi Container Builder:
$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3
Obraz jest automatycznie zapisywany w Container Registry.
13. Uruchamianie panelu graficznego Kubernetes
W najnowszych wersjach Kubernetes wprowadziliśmy graficzny interfejs użytkownika (panel). Ten interfejs pozwala szybko rozpocząć pracę i ustawia niektóre funkcje dostępne w interfejsie wiersza poleceń jako przystępniejszy i łatwiejszy 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żesz zobaczyć komunikat „Brak autoryzacji” ale nie przejmuj się tym. Aby uzyskać dostęp do panelu, usuń „?authuser=3” i zastąp go fragmentem „/ui”.
Korzystaj z graficznego panelu Kubernetes i używaj go do wdrażania aplikacji skonteneryzowanych oraz monitorowania klastrów i zarządzania nimi.
Możesz też uzyskać dostęp do panelu z programu lub komputera lokalnego, korzystając z podobnych instrukcji dostępnych po kliknięciu w konsoli internetowej przycisku „Połącz” obok klastra, który chcesz monitorować.
Po zakończeniu pracy z panelem możesz nacisnąć Control + C, aby zatrzymać serwer proxy. Aby dowiedzieć się więcej o panelu Kubernetes, obejrzyj prezentację panelu.
14. Logowanie
Za pomocą polecenia kubectl logs możesz pobrać logi kontenera działającego w Kubernetes. Gdy do uruchamiania zarządzanych klastrów Kubernetes używasz Google Kubernetes Engine, wszystkie logi są automatycznie przekazywane i przechowywane w usłudze Google Cloud Logging. Aby wyświetlić wszystkie dane wyjściowe dzienników podów, w konsoli Google Cloud wybierz Stackdriver → Logowanie → Logi:
W konsoli logowania możesz przejść do kontenera GKE, aby wyświetlić wszystkie logi zebrane z STDOUT:
Możesz na niej opcjonalnie wyeksportować logi do Google BigQuery, aby je dokładniej przeanalizować, lub skonfigurować alerty oparte na logach. Nie uda nam się tego zrobić w dzisiejszym module.
15. Gratulacje!
To już koniec tego prostego ćwiczenia z programowania z wykorzystaniem ASP.NET Core i Kubernetes. Zebraliśmy już tylko ślady tej technologii. Zachęcamy do dalszych poszukiwań z wykorzystaniem własnych podów, kontrolerów replikacji i usług, ale także sprawdzenie sond żywotności (kontroli stanu) i rozważenie bezpośredniego korzystania z interfejsu Kubernetes API.
Czyszczenie danych
Znakomicie. Czas na pozbycie się zbędnych zasobów (aby zmniejszyć koszty i zadbać o dobre korzystanie z chmury).
Usuń obiekt Deployment (co powoduje też usunięcie uruchomionych podów) i usługę (co powoduje 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, które uruchamiają klaster.
Na koniec usuń zasobnik na dane rejestru Dockera, który hostuje Twoje 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/...
Oczywiście możesz też usunąć cały projekt, ale spowoduje to utratę całej skonfigurowanej konfiguracji płatności (najpierw musisz wyłączyć płatności za projekt). Dodatkowo usunięcie projektu spowoduje zatrzymanie wszystkich płatności 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ć usługę i wdrożyć uaktualnienie.
- Jak uruchomić graficzny panel Kubernetes.
Następne kroki
- Dowiedz się więcej o Kubernetes ( http://kubernetes.io/).
- Dowiedz się więcej o systemie Windows w Google Cloud Platform.
- Dowiedz się więcej o .NET w Google Cloud Platform.
- Dowiedz się więcej o SQL Server w Google Cloud Platform.
- Dowiedz się więcej o narzędziach Cloud dla Visual Studio.
- Dowiedz się więcej o narzędziach Cloud dla PowerShell.
Licencja
To zadanie jest licencjonowane na podstawie ogólnej licencji Creative Commons Attribution 2.0.