GSP1123
Opis
Zarządzanie tworzeniem i wdrażaniem aplikacji oraz jej bieżącymi
aktualizacjami jest podstawą operacji w chmurze. Najważniejsze związane z tym
zagadnienia dotyczą optymalizacji zasobów pod kątem zapewniania zgodności
z gwarancjami jakości usług, wdrażania zmian w kodzie, bezproblemowych
aktualizacji maszyn wirtualnych oraz konfigurowania sieci i równoważenia
obciążenia. Azure korzysta z potoków DevOps, zestawów skalowania maszyn
wirtualnych na potrzeby autoskalowania i Azure IAM w celu kontroli dostępu.
Podmioty zabezpieczeń usług są kluczowe dla wykonywania aplikacji
i komunikacji, a sieci wirtualne, systemy równoważenia obciążenia, sondy stanu
i zestawy dostępnych maszyn uzupełniają konfigurację infrastruktury.
Aktualizowanie maszyn wirtualnych może obejmować aktualizacje obrazów, ponowne
wdrażanie lub aktualizacje zarządzanych instancji z zaplanowaną konserwacją.
Google Cloud zapewnia porównywalną elastyczność. Skrypty startowe mogą
pobierać aktualizacje kodu, co ułatwia wdrażanie aktualizacji kroczących bez
przestojów. Chociaż istnieją rozwiązania takie jak GKE i App Engine, Compute
Engine zapewnia szczegółową kontrolę nad maszynami wirtualnymi i systemami
równoważenia obciążenia. W tym laboratorium dowiesz się, jak wdrożyć
i skalować aplikację e-commerce „Fancy Store” w Compute Engine. Dzięki temu
poznasz to zaawansowane podejście do zarządzania aplikacjami internetowymi.
Cele
Z tego laboratorium nauczysz się, jak:
Na końcu laboratorium będziesz mieć instancje w zarządzanych grupach
instancji, które zapewniają automatyczną naprawę, równoważenie obciążenia,
autoskalowanie i aktualizacje kroczące Twojej witryny.
Konfiguracja i wymagania
Zanim klikniesz przycisk Rozpocznij moduł
Zapoznaj się z tymi instrukcjami. Moduły mają limit czasowy i nie można ich zatrzymać. Gdy klikniesz Rozpocznij moduł, na liczniku wyświetli się informacja o tym, na jak długo udostępniamy Ci zasoby Google Cloud.
W tym praktycznym module możesz spróbować swoich sił w wykonywaniu opisywanych działań w prawdziwym środowisku chmury, a nie w jego symulacji lub wersji demonstracyjnej. Otrzymasz nowe, tymczasowe dane logowania, dzięki którym zalogujesz się i uzyskasz dostęp do Google Cloud na czas trwania modułu.
Do ukończenia modułu potrzebne będą:
- Dostęp do standardowej przeglądarki internetowej (zalecamy korzystanie z przeglądarki Chrome).
Uwaga: uruchom ten moduł w oknie incognito (zalecane) lub przeglądania prywatnego. Dzięki temu unikniesz konfliktu między swoim kontem osobistym a kontem do nauki, co mogłoby spowodować naliczanie dodatkowych opłat na koncie osobistym.
- Odpowiednia ilość czasu na ukończenie modułu – pamiętaj, że gdy rozpoczniesz, nie możesz go wstrzymać.
Uwaga: w tym module używaj tylko konta do nauki. Jeśli użyjesz innego konta Google Cloud, mogą na nim zostać naliczone opłaty.
Rozpoczynanie laboratorium i logowanie się w konsoli Google Cloud
-
Kliknij przycisk Rozpocznij laboratorium. Jeśli laboratorium jest odpłatne, otworzy się okno, w którym możesz wybrać formę płatności.
Po prawej stronie znajduje się panel Konfiguracja laboratorium i dostęp do niego z następującymi elementami:
- przyciskiem Otwórz konsolę Google Cloud;
- uprawnieniami tymczasowymi (nazwą użytkownika i hasłem), których musisz użyć w tym laboratorium;
- innymi informacjami potrzebnymi do ukończenia modułu.
Pamiętaj, że minutnik laboratorium znajduje się u góry strony i pokazuje pozostały czas.
-
Kliknij Otwórz konsolę Cloud (lub kliknij prawym przyciskiem myszy i wybierz Otwórz link w oknie incognito, jeśli korzystasz z przeglądarki Chrome).
Laboratorium uruchomi zasoby, po czym otworzy nową kartę ze stroną logowania.
Wskazówka: karty możesz otworzyć w osobnych oknach obok siebie.
Uwaga: jeśli pojawi się okno Wybierz konto, kliknij Użyj innego konta.
-
W razie potrzeby skopiuj nazwę użytkownika znajdującą się poniżej i wklej ją w oknie logowania.
{{{user_0.username | "Username"}}}
Nazwę użytkownika znajdziesz też w panelu Konfiguracja laboratorium i dostęp do niego.
-
Kliknij Dalej.
-
Skopiuj podane niżej hasło i wklej je w oknie powitania.
{{{user_0.password | "Password"}}}
Hasło znajdziesz też w panelu Konfiguracja laboratorium i dostęp do niego.
-
Kliknij Dalej.
Ważne: musisz użyć danych logowania podanych w laboratorium. Nie używaj danych logowania na swoje konto Google Cloud.
Uwaga: korzystanie z własnego konta Google Cloud w tym laboratorium może wiązać się z dodatkowymi opłatami.
-
Na kolejnych stronach wykonaj następujące czynności:
- Zaakceptuj Warunki korzystania z usługi.
- Nie dodawaj opcji odzyskiwania ani uwierzytelniania dwuskładnikowego (ponieważ konto ma charakter tymczasowy).
- Nie rejestruj się w bezpłatnych wersjach próbnych.
Poczekaj, aż na karcie otworzy się konsola Google Cloud.
Uwaga: aby uzyskać dostęp do produktów i usług Google Cloud, kliknij Menu nawigacyjne lub wpisz nazwę usługi albo produktu w polu Szukaj.
Aktywowanie Cloud Shell
Cloud Shell to maszyna wirtualna oferująca wiele narzędzi dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud. Dzięki wierszowi poleceń Cloud Shell zyskujesz dostęp do swoich zasobów Google Cloud.
-
Kliknij Aktywuj Cloud Shell
na górze konsoli Google Cloud.
-
Kliknij te okna:
- Przejdź przez okno z informacjami o Cloud Shell.
- Zezwól Cloud Shell na używanie Twoich danych logowania w celu wywoływania interfejsu Google Cloud API.
Po połączeniu użytkownik od razu jest uwierzytelniony. Uruchomi się Twój projekt o identyfikatorze Project_ID . Dane wyjściowe zawierają wiersz z zadeklarowanym identyfikatorem Project_ID dla tej sesji:
Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}
gcloud to narzędzie wiersza poleceń Google Cloud. Jest ono już zainstalowane w Cloud Shell i obsługuje funkcję autouzupełniania po naciśnięciu tabulatora.
- (Opcjonalnie) Aby wyświetlić listę aktywnych kont, użyj tego polecenia:
gcloud auth list
- Kliknij Autoryzuj.
Dane wyjściowe:
ACTIVE: *
ACCOUNT: {{{user_0.username | "ACCOUNT"}}}
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- (Opcjonalnie) Aby wyświetlić identyfikator projektu, użyj tego polecenia:
gcloud config list project
Dane wyjściowe:
[core]
project = {{{project_0.project_id | "PROJECT_ID"}}}
Uwaga: pełną dokumentację gcloud w Google Cloud znajdziesz w opisie gcloud CLI.
Ustawianie domyślnej strefy
- Ustaw domyślną strefę i konfigurację projektu:
gcloud config set compute/zone {{{project_0.default_zone|ZONE}}}
Więcej informacji znajdziesz w dokumentacji regionów i stref
(w języku angielskim).
Uwaga: kiedy uruchamiasz narzędzie gcloud na swoim komputerze, ustawienia konfiguracji są zachowywane między sesjami. Jednak w Cloud Shell musisz je ustawiać dla każdej nowej sesji lub połączenia.
Zadanie 1. Włączanie interfejsu Compute Engine API i edytora
Włącz interfejs
Compute Engine API.
- Aby to zrobić, uruchom to polecenie:
gcloud services enable compute.googleapis.com
Zadanie 2. Tworzenie zasobnika Cloud Storage
W tym zadaniu skonfigurujesz zasobnik Cloud Storage, w którym będziesz
przechowywać utworzony kod oraz skrypty startowe.
-
Wykonaj w Cloud Shell to polecenie, aby utworzyć nowy zasobnik Cloud
Storage:
gcloud storage buckets create gs://fancy-store-{{{project_0.project_id | BUCKET}}}
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Utworzenie zasobnika Cloud Storage
Zadanie 3. Klonowanie repozytorium źródłowego
Podstawą Twojej witryny będzie istniejąca witryna sklepu internetowego Fancy
Store oparta na repozytorium monolith-to-microservices.
W tym zadaniu sklonujesz kod źródłowy, aby skoncentrować się na aspektach
wdrażania w Compute Engine. Później w trakcie tego laboratorium przeprowadzisz
niewielką aktualizację kodu, która pokaże, jak proste jest aktualizowanie
w Compute Engine.
-
Uruchom te polecenia, aby sklonować kod źródłowy, a następnie przejść do
katalogu
monolith-to-microservices:
git clone https://github.com/googlecodelabs/monolith-to-microservices.git
cd ~/monolith-to-microservices
-
Wykonaj początkową kompilację kodu, by umożliwić lokalne uruchamianie
aplikacji:
./setup.sh
Wykonanie tego skryptu zajmie kilka minut.
-
Po jego zakończeniu sprawdź, czy w Cloud Shell uruchomiona jest zgodna
wersja nodeJS. Użyj tego polecenia:
{{{project_0.startup_script.node_nvm_command | nvm install --lts}}}
-
Następnie uruchom poniższe polecenie, by przetestować aplikację, przejść do
katalogu
microservices i uruchomić serwer WWW:
cd microservices
npm start
Wynik powinien wyglądać mniej więcej tak, jak przedstawiono poniżej.
Dane wyjściowe:
Products microservice listening on port 8082!
Frontend microservice listening on port 8080!
Orders microservice listening on port 8081!
-
Kliknij ikonę podglądu w przeglądarce, aby wyświetlić
podgląd aplikacji, a następnie wybierz
Podejrzyj na porcie 8080.
Otworzy się nowe okno, w którym zobaczysz frontend sklepu Fancy Store.
Uwaga: po wybraniu opcji podglądu będzie widoczny frontend. Strony Products i Orders nie będą jednak działać, ponieważ te usługi nie zostały jeszcze udostępnione.
-
Po przejrzeniu strony internetowej zamknij to okno i naciśnij CTRL+C w oknie
terminala, by zatrzymać proces serwera WWW.
Zadanie 4. Tworzenie instancji Compute Engine
Teraz kolej na rozpoczęcie wdrażania instancji Compute Engine.
W kolejnych krokach wykonasz te czynności:
- Utworzysz skrypt startowy służący do konfigurowania instancji.
- Sklonujesz kod źródłowy i prześlesz go do Cloud Storage.
-
Wdrożysz instancję Compute Engine, która będzie hostować mikroserwisy
backendu.
-
Ponownie skonfigurujesz kod frontendu w sposób umożliwiający korzystanie
z instancji mikroserwisów backendu.
-
Wdrożysz instancję Compute Engine, która będzie hostować mikroserwis
frontendu.
- Skonfigurujesz sieć w sposób umożliwiający komunikację.
Tworzenie skryptu startowego
Skrypt startowy służy do instruowania instancji, co ma robić za każdym razem,
gdy jest uruchamiana. W ten sposób instancje zostaną automatycznie
skonfigurowane.
-
Na pasku narzędzi Cloud Shell kliknij Otwórz edytor, aby
otworzyć edytor kodu.

-
Przejdź do folderu monolith-to-microservices.
-
Kliknij Plik > Nowy plik i utwórz plik
o nazwie startup-script.sh
-
Wklej do pliku podany poniżej kod.
#!/bin/bash
# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor psmisc
# Install nodejs
mkdir -p /opt/nodejs
curl https://nodejs.org/dist/v16.14.0/node-v16.14.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
ln -sf /opt/nodejs/bin/node /usr/bin/node
ln -sf /opt/nodejs/bin/npm /usr/bin/npm
# Get the application source code from the Google Cloud Storage bucket.
mkdir -p /fancy-store
gcloud storage cp -r gs://fancy-store-[PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/
# Install app dependencies.
cd /fancy-store/
npm install
# Create a nodeapp user. The application will run as this user.
id -u nodeapp >/dev/null 2>&1 || useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /fancy-store
# Configure supervisor to run the node app.
cat >/etc/supervisor/conf.d/node-app.conf << EOF
[program:nodeapp]
directory=/fancy-store
command=npm start
autostart=true
autorestart=true
user=nodeapp
environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production"
stdout_logfile=syslog
stderr_logfile=syslog
EOF
supervisorctl reread
supervisorctl update
-
Aby zapisać plik, kliknij Plik > Zapisz.
-
W edytorze kodu Cloud Shell sprawdź, czy „opcja „End of
Line Sequence” jest ustawiona na „LF”, a nie „CRLF”. Możesz to zrobić
w prawym dolnym rogu edytora.

-
Jeśli zobaczysz ustawienie CRLF, kliknij CRLF i wybierz
z menu LF, aby zmienić to ustawienie.
-
Zastąp zmienną
[PROJECT_ID] w pliku
startup-script.sh identyfikatorem projektu:
{{{project_0.project_id | PROJECT_ID}}}.
Skrypt startowy wykonuje te zadania:
- Instaluje agenta logowania. Agent automatycznie zbiera logi z syslog.
-
Instaluje środowisko Node.js i system Supervisor. System Supervisor
uruchamia aplikację jako demon.
-
Kopiuje kod źródłowy aplikacji z zasobnika Cloud Storage i instaluje
zależności.
-
Konfiguruje w systemie Supervisor uruchamianie aplikacji. System Supervisor
dba o to, by aplikacja była uruchamiana ponownie po nieoczekiwanym
zakończeniu działania lub po zatrzymaniu przez administratora bądź inny
proces. Wysyła także strumienie stdin i stderr do syslog, by umożliwić ich
zbieranie przez agenta logowania.
-
Wróć do terminala Cloud Shell i wykonaj to polecenie, by skopiować plik
startup-script.sh do swojego zasobnika:
gcloud storage cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-{{{project_0.project_id | BUCKET}}}
Będzie teraz dostępny w:
https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh.
[BUCKET_NAME] reprezentuje nazwę zasobnika Cloud Storage.
Domyślnie będzie widoczny tylko dla autoryzowanych użytkowników i kont usługi,
a więc nie będzie dostępny za pomocą przeglądarki. Instancje Compute Engine
będą automatycznie mieć do niego dostęp za pośrednictwem swoich kont usługi.
Kopiowanie kodu do zasobnika Cloud Storage
Gdy instancje uruchamiają się, pobierają kod z zasobnika Cloud Storage,
dlatego niektóre zmienne konfiguracyjne możesz przechowywać w kodzie w pliku
.env.
Uwaga: możesz również zaprogramować pobieranie zmiennych środowiskowych z innego miejsca, ale do celów demonstracyjnych dobrze jest użyć tej prostej metody obsługi konfiguracji. W środowisku produkcyjnym zmienne środowiskowe byłyby prawdopodobnie przechowywane poza kodem.
- Zapisz kopię kodu w zasobniku:
cd ~
rm -rf monolith-to-microservices/*/node_modules
gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | BUCKET}}}/
Uwaga: katalogi zależności node_modules są usuwane, by zapewnić jak najszybsze i najwydajniejsze działanie kopii. Są one odtwarzane w instancjach podczas ich uruchamiania.
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Skopiowanie skryptu startowego i kodu do zasobnika Cloud Storage
Wdrażanie instancji backendowej
Pierwszą wdrożoną instancją będzie instancja backendowa udostępniająca
mikroserwisy zamówień i produktów.
Uwaga: w środowisku produkcyjnym warto oddzielić poszczególne mikroserwisy i umieścić je we własnych instancjach oraz grupach instancji, co pozwala na ich niezależne skalowanie. Dla celów demonstracyjnych obydwa mikroserwisy backendu (do obsługi zamówień i produktów) będą się znajdować w tej samej instancji i grupie instancji.
-
Wykonaj poniższe polecenie, aby utworzyć instancję
e2-medium skonfigurowaną do korzystania ze skryptu startowego.
Jest ona oznaczona tagiem jako instancja backend, dlatego
możesz do niej później zastosować konkretne reguły zapory sieciowej:
gcloud compute instances create backend \
--machine-type=e2-medium \
--tags=backend \
--metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | BUCKET}}}/startup-script.sh
Uwaga: jeśli pojawi się prośba o podanie strefy, sprawdź, czy w części tego laboratorium dotyczącej konfiguracji ustawiono strefę domyślną.
Konfigurowanie połączenia z backendem
Przed wdrożeniem frontendu aplikacji musisz zaktualizować konfigurację,
wskazując w niej wdrożony przed chwilą backend.
-
Za pomocą tego polecenia pobierz zewnętrzny adres IP backendu; odszukaj
instancję backendową w kolumnie
EXTERNAL_IP:
gcloud compute instances list
Przykładowe dane wyjściowe:
NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS
backend {{{ project_0.default_zone | "ZONE" }}} e2-medium 10.128.0.2 34.68.223.88 RUNNING
-
Skopiuj zewnętrzny adres IP backendu.
-
W eksploratorze Cloud Shell przejdź do folderu
monolith-to-microservices > react-app.
-
W edytorze kodu wybierz View >
Toggle Hidden Files, aby wyświetlić plik
.env.
-
Zmodyfikuj plik .env w taki sposób, by wskazywał zewnętrzny
adres IP backendu. [BACKEND_ADDRESS] reprezentuje
zewnętrzny adres IP instancji backendowej ustalony za pomocą powyższego
polecenia gcloud.
-
W pliku .env zastąp ciąg znaków
localhost adresem [BACKEND_ADDRESS]:
REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products
-
Zapisz plik.
-
Uruchom to polecenie, aby ponownie utworzyć aplikację
react-app, co spowoduje zaktualizowanie kodu frontendu:
cd ~/monolith-to-microservices/react-app
npm install && npm run-script build
-
Następnie uruchom to polecenie, aby skopiować kod aplikacji do zasobnika
Cloud Storage:
cd ~
rm -rf monolith-to-microservices/*/node_modules
gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | BUCKET}}}/
Wdrażanie instancji frontendowej
Po skonfigurowaniu kodu możesz wdrożyć instancję frontendową.
-
Aby wdrożyć instancję
frontend, uruchom polecenie podobne do
wcześniejszego. Na potrzeby zapory sieciowej ta instancja jest oznaczona
tagiem frontend:
gcloud compute instances create frontend \
--machine-type=e2-medium \
--tags=frontend \
--metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | BUCKET}}}/startup-script.sh
Uwaga: polecenie wdrażania i skrypt startowy są używane w przypadku instancji frontendu i backendu dla uproszczenia, a także dlatego, że kod jest domyślnie skonfigurowany do uruchamiania wszystkich mikroserwisów. W rezultacie w tym przykładzie wszystkie mikroserwisy są uruchamiane zarówno we frontendzie, jak i w backendzie. W środowisku produkcyjnym byłyby uruchamiane tylko te mikroserwisy, które są potrzebne w poszczególnych komponentach.
Konfigurowanie sieci
W tej sekcji utworzysz reguły zapory sieciowej zezwalające na dostęp do
portu 8080 w przypadku frontendu oraz do portów 8081 i 8082 w przypadku
backendu. W poleceniach związanych z zaporami sieciowymi używane są tagi
przypisane podczas tworzenia instancji dla aplikacji:
- Aby skonfigurować reguły zapory sieciowej, uruchom te polecenia:
gcloud compute firewall-rules create fw-fe \
--allow tcp:8080 \
--target-tags=frontend
gcloud compute firewall-rules create fw-be \
--allow tcp:8081-8082 \
--target-tags=backend
Witryna powinna być teraz w pełni funkcjonalna.
-
Aby przejść do zewnętrznego adresu IP
frontendu, musisz znać
ten adres. Uruchom to polecenie i znajdź adres znajdujący się w kolumnie
EXTERNAL_IP wiersza odpowiadającego instancji frontend:
gcloud compute instances list
Przykładowe dane wyjściowe:
NAME: backend
ZONE: {{{ project_0.default_zone | "ZONE" }}}
MACHINE_TYPE: e2-medium
PREEMPTIBLE:
INTERNAL_IP: 10.150.0.2
EXTERNAL_IP: 34.86.128.228
STATUS: RUNNING
NAME: frontend
ZONE: {{{ project_0.default_zone | "ZONE" }}}
MACHINE_TYPE: e2-medium
PREEMPTIBLE:
INTERNAL_IP: 10.150.0.3
EXTERNAL_IP: 35.199.2.193
STATUS: RUNNING
Uruchomienie i skonfigurowanie instancji może zająć kilka minut.
-
Zaczekaj 30 sekund, a potem wykonaj poniższe polecenie, aby monitorować,
kiedy aplikacja będzie gotowa. Zastąp w nim ciąg znaków
[FRONTEND_ADDRESS] zewnętrznym adresem IP instancji
frontendowej:
watch -n 2 curl http://[FRONTEND_ADDRESS]:8080
Witryna powinna być gotowa, gdy wyświetlą się dane wyjściowe podobne do
poniższych.

-
Aby anulować polecenie watch, naciśnij Ctrl + C.
-
Otwórz nową kartę przeglądarki i otwórz stronę
http://[FRONTEND_ADDRESS]:8080, aby uzyskać dostęp do
witryny. Ciąg znaków [FRONTEND_ADDRESS] reprezentuje zewnętrzny adres IP
frontendu określony powyżej.
-
Spróbuj otworzyć strony
Products i Orders – powinny teraz
działać.
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Wdrożenie instancji i skonfigurowanie sieci
Zadanie 5. Tworzenie zarządzanych grup instancji
Aby umożliwić skalowanie aplikacji, zostaną utworzone zarządzane grupy
instancji, które będą używać instancji frontend i backend
jako szablonów instancji.
Zarządzana grupa instancji zawiera identyczne instancje, którymi możesz
zarządzać jak pojedynczą encją w pojedynczej strefie. Zarządzane grupy
instancji zapewniają wysoką dostępność aplikacji przez aktywne utrzymywanie
instancji w stanie uruchomienia.
W tym laboratorium będziesz korzystać z zarządzanych grup instancji do obsługi
funkcji automatycznej naprawy, równoważenia obciążenia, autoskalowania
i aktualizacji kroczących w instancjach frontendowych oraz backendowych.
Tworzenie szablonu instancji z instancji źródłowej
Zanim utworzysz zarządzaną grupę instancji, musisz utworzyć szablon instancji,
który będzie stanowić podstawę grupy. Szablony instancji pozwalają na
zdefiniowanie typu maszyny, obrazu dysku rozruchowego lub obrazu kontenera,
sieci oraz innych właściwości instancji używanych przy tworzeniu nowych
instancji maszyn wirtualnych. Za pomocą szablonów instancji możesz tworzyć
instancje w zarządzanej grupie instancji, a nawet pojedyncze instancje.
Utwórz szablon instancji na podstawie wcześniej utworzonych przez Ciebie
instancji.
- Najpierw uruchom to polecenie, aby zatrzymać obie instancje:
gcloud compute instances stop frontend
gcloud compute instances stop backend
-
Następnie uruchom to polecenie, aby utworzyć szablon instancji na podstawie
każdej z instancji źródłowych:
gcloud compute instance-templates create fancy-fe \
--source-instance=frontend
gcloud compute instance-templates create fancy-be \
--source-instance=backend
-
Użyj tego polecenia, aby sprawdzić, czy szablony instancji zostały
utworzone:
gcloud compute instance-templates list
Przykładowe dane wyjściowe:
NAME MACHINE_TYPE PREEMPTIBLE CREATION_TIMESTAMP
fancy-be e2-medium 2020-02-03T10:34:12.966-08:00
fancy-fe e2-medium 2020-02-03T10:34:01.082-08:00
-
Po utworzeniu szablonów instancji uruchom poniższe polecenie, aby usunąć
maszynę wirtualną
backend i zaoszczędzić miejsce na zasoby:
gcloud compute instances delete backend
- Wpisz y, gdy pojawi się prośba.
Normalnie można by też usunąć maszynę wirtualną frontend, ale
użyjesz jej do zaktualizowania szablonu instancji w dalszej części
laboratorium.
Tworzenie zarządzanej grupy instancji.
-
Następnie uruchom te polecenia, aby utworzyć 2 zarządzane grupy instancji –
jedną dla frontendu i jedną dla backendu:
gcloud compute instance-groups managed create fancy-fe-mig \
--base-instance-name fancy-fe \
--size 2 \
--template fancy-fe
gcloud compute instance-groups managed create fancy-be-mig \
--base-instance-name fancy-be \
--size 2 \
--template fancy-be
Te zarządzane grupy instancji używają szablonów instancji. Są one
skonfigurowane dla 2 instancji – każda będzie uruchamiana we własnej grupie.
Nazwy instancji są tworzone automatycznie. Mają format ciągu znaków
base-instance-name z dołączonymi losowymi znakami.
-
W Twojej aplikacji mikroserwis
frontend działa na porcie 8080,
a mikroserwis backend – na porcie 8081 (orders)
i na porcie 8082 (products):
gcloud compute instance-groups set-named-ports fancy-fe-mig \
--named-ports frontend:8080
gcloud compute instance-groups set-named-ports fancy-be-mig \
--named-ports orders:8081,products:8082
Ponieważ są to porty niestandardowe, określa się je za pomocą nazwanych
portów. Nazwane porty to metadane w postaci par klucz-wartość reprezentujących
nazwę usługi i port, na którym ona działa. Nazwane porty można przypisać do
grupy instancji, dzięki czemu usługa będzie dostępna we wszystkich instancjach
w grupie. Te informacje są używane przez usługę równoważenia obciążenia HTTP,
którą skonfigurujesz później.
Konfigurowanie automatycznej naprawy
Aby zwiększyć dostępność samej aplikacji i sprawdzić, czy odpowiada,
skonfiguruj zasadę automatycznej naprawy dla zarządzanych grup instancji.
Zasada automatycznej naprawy opiera się na kontroli stanu aplikacji, która
polega na sprawdzaniu, czy aplikacja odpowiada w oczekiwany sposób.
Sprawdzenie, czy aplikacja odpowiada, jest bardziej szczegółowe niż zwykła
weryfikacja stanu uruchomienia, co jest zachowaniem domyślnym.
Uwaga: w przypadku systemów równoważenia obciążenia oraz automatycznej naprawy stosowane są osobne kontrole stanu. Kontrole stanu związane z równoważeniem obciążenia mogą i powinny być bardziej agresywne, ponieważ umożliwiają określenie, czy do instancji dociera ruch generowany przez użytkowników. Pożądane jest szybkie identyfikowanie instancji, które nie odpowiadają, aby w razie potrzeby można było przekierować ruch.
W przeciwieństwie do tego kontrola stanu związana z automatyczną naprawą powoduje, że Compute Engine aktywnie zastępuje uszkodzone instancje. Z tego względu powinna być bardziej restrykcyjna niż w przypadku równoważenia obciążenia.
-
Uruchom poniższe polecenia, aby utworzyć kontrolę stanu, która naprawi
instancję, jeśli ta 3 razy z rzędu zasygnalizuje niepoprawny stan dla usług
frontend i backend:
gcloud compute health-checks create http fancy-fe-hc \
--port 8080 \
--check-interval 30s \
--healthy-threshold 1 \
--timeout 10s \
--unhealthy-threshold 3
gcloud compute health-checks create http fancy-be-hc \
--port 8081 \
--request-path=/api/orders \
--check-interval 30s \
--healthy-threshold 1 \
--timeout 10s \
--unhealthy-threshold 3
-
Użyj tych poleceń, żeby utworzyć regułę zapory sieciowej, która umożliwi
sondom kontroli stanu nawiązanie połączenia z mikroserwisami na portach 8080
i 8081:
gcloud compute firewall-rules create allow-health-check \
--allow tcp:8080-8081 \
--source-ranges 130.211.0.0/22,35.191.0.0/16 \
--network default
-
Uruchom następujące polecenie, aby zastosować kontrole stanu do odpowiednich
usług:
gcloud compute instance-groups managed update fancy-fe-mig \
--health-check fancy-fe-hc \
--initial-delay 300
gcloud compute instance-groups managed update fancy-be-mig \
--health-check fancy-be-hc \
--initial-delay 300
Uwaga: zanim funkcja automatycznej naprawy zacznie monitorować instancje w grupie, może minąć 15 minut.
-
Kontynuuj laboratorium, aby dać funkcji automatycznej naprawy dość czasu na
rozpoczęcie monitorowania instancji w grupie. Aby przetestować automatyczną
naprawę, na końcu modułu przeprowadzisz symulację uszkodzenia.
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Utworzenie zarządzanych grup instancji
Zadanie 6. Tworzenie systemów równoważenia obciążenia
Zarządzane grupy instancji możesz uzupełnić systemami równoważenia obciążenia
HTTP(S) służącymi do obsługi ruchu skierowanego do mikroserwisów frontendu
i backendu, a także mapowaniami umożliwiającymi kierowanie ruchu do
odpowiednich usług backendu na podstawie reguł określania ścieżek. Udostępnia
to pojedynczy adres IP systemu równoważenia obciążenia dla wszystkich usług.
Więcej informacji o możliwościach równoważenia obciążenia w Google Cloud
znajdziesz w artykule
omawiającym równoważenie obciążenia.
Tworzenie systemu równoważenia obciążenia HTTP(S)
Google Cloud oferuje wiele różnych typów systemów równoważenia obciążenia.
W tym laboratorium do obsługi ruchu używasz systemu równoważenia obciążenia
HTTP(S). Struktura systemu równoważenia obciążenia HTTP jest taka:
-
Reguła przekierowania kieruje żądania przychodzące do docelowego serwera
proxy HTTP.
-
Docelowy serwer proxy HTTP porównuje każde żądanie z mapą URL, aby określić
dla niego odpowiednią usługę backendu.
-
Usługa backendu kieruje każde żądanie do odpowiedniego backendu na podstawie
możliwości obsługi, strefy i stanu podłączonych instancji backendowych. Stan
każdej instancji backendowej jest weryfikowany przy użyciu kontroli stanu
HTTP. Jeśli w usłudze backendu skonfigurowano użycie kontroli stanu HTTPS
lub HTTP/2, w drodze do instancji backendowej żądanie zostaje zaszyfrowane.
-
W sesjach połączenia między systemem równoważenia obciążenia a instancją
możesz używać protokołu HTTP, HTTPS lub HTTP/2. Jeśli chcesz używać
protokołu HTTPS lub HTTP/2, każda instancja usług backendu musi mieć
certyfikat SSL.
Uwaga: aby uniknąć komplikacji związanych z użyciem certyfikatów SSL, dla celów demonstracyjnych możesz użyć protokołu HTTP zamiast HTTPS. W środowiskach produkcyjnych zaleca się, by zawsze, gdy to możliwe, używać protokołu HTTPS, który umożliwia szyfrowanie.
-
Utwórz kontrole stanu, które będą używane do określenia instancji mogących
obsłużyć ruch związany z poszczególnymi usługami
gcloud compute http-health-checks create fancy-fe-frontend-hc \
--request-path / \
--port 8080
gcloud compute http-health-checks create fancy-be-orders-hc \
--request-path /api/orders \
--port 8081
gcloud compute http-health-checks create fancy-be-products-hc \
--request-path /api/products \
--port 8082
Uwaga: te kontrole stanu są przeznaczone dla systemu równoważenia obciążenia i obsługują wyłącznie kierowanie ruchu z systemu równoważenia obciążenia. Nie zapewniają odtwarzania instancji w zarządzanych grupach instancji.
-
Utwórz docelowe usługi backendu dla ruchu z systemu równoważenia obciążenia.
Będą one korzystać z utworzonych kontroli stanu i nazwanych portów:
gcloud compute backend-services create fancy-fe-frontend \
--http-health-checks fancy-fe-frontend-hc \
--port-name frontend \
--global
gcloud compute backend-services create fancy-be-orders \
--http-health-checks fancy-be-orders-hc \
--port-name orders \
--global
gcloud compute backend-services create fancy-be-products \
--http-health-checks fancy-be-products-hc \
--port-name products \
--global
-
Dodaj
usługi backendu
systemu równoważenia obciążenia:
gcloud compute backend-services add-backend fancy-fe-frontend \
--instance-group fancy-fe-mig \
--instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \
--global
gcloud compute backend-services add-backend fancy-be-orders \
--instance-group fancy-be-mig \
--instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \
--global
gcloud compute backend-services add-backend fancy-be-products \
--instance-group fancy-be-mig \
--instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \
--global
-
Utwórz mapę URL. Mapa URL określa, które adresy URL są kierowane do których
usług backendu:
gcloud compute url-maps create fancy-map \
--default-service fancy-fe-frontend
-
Określ dopasowania ścieżek, które umożliwiają skierowanie ścieżek
/api/orders i /api/products do odpowiednich usług:
gcloud compute url-maps add-path-matcher fancy-map \
--default-service fancy-fe-frontend \
--path-matcher-name orders \
--path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"
- Utwórz serwer proxy, który stworzy połączenie z mapą URL:
gcloud compute target-http-proxies create fancy-proxy \
--url-map fancy-map
-
Utwórz globalną regułę przekierowania, która łączy publiczny adres IP i port
z serwerem proxy:
gcloud compute forwarding-rules create fancy-http-rule \
--global \
--target-http-proxy fancy-proxy \
--ports 80
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Utworzenie systemów równoważenia obciążenia HTTP(S)
Aktualizowanie konfiguracji
Teraz gdy masz już nowy statyczny adres IP, zaktualizuj kod instancji
frontend w taki sposób, by wskazywał ten nowy adres zamiast
używanego wcześniej adresu efemerycznego, który wskazywał instancję
backend.
-
W Cloud Shell przejdź do folderu
react-app, w którym znajduje
się plik .env zawierający konfigurację:
cd ~/monolith-to-microservices/react-app/
- Znajdź adres IP systemu równoważenia obciążenia:
gcloud compute forwarding-rules list --global
Przykładowe dane wyjściowe:
NAME: fancy-http-rule
REGION:
IP_ADDRESS: 34.111.203.235
IP_PROTOCOL: TCP
TARGET: fancy-proxy
-
Wróć do edytora Cloud Shell i ponownie zmodyfikuj plik
.env tak, aby wskazywał publiczny adres IP systemu równoważenia
obciążenia. Ciąg znaków [LB_IP] reprezentuje zewnętrzny adres
IP instancji backendowej określony powyżej.
REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products
Uwaga: w nowym adresie porty są usunięte, ponieważ system równoważenia obciążenia jest skonfigurowany pod kątem obsługi tego przekierowania
-
Zapisz plik.
-
Utwórz ponownie react-app. Zaktualizuje to kod frontendu:
cd ~/monolith-to-microservices/react-app
npm install && npm run-script build
- Skopiuj kod aplikacji do zasobnika:
cd ~
rm -rf monolith-to-microservices/*/node_modules
gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | BUCKET}}}/
Aktualizowanie instancji frontendowych
Po opracowaniu nowego kodu i konfiguracji instancje frontendowe w zarządzanej
grupie instancji powinny pobrać ten nowy kod.
-
Ponieważ instancje pobierają kod podczas ich uruchamiania, możesz uruchomić
polecenie kroczącego restartu:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \
--max-unavailable 100%
Uwaga: w tym przykładzie zastąpień kroczących za pomocą parametru --max-unavailable wskazujesz, że wszystkie maszyny można zastąpić natychmiast. Gdyby nie było tego parametru, polecenie zachowałoby aktywną instancję, restartując inne, aby zapewnić dostępność. Dla celów testowych określa się natychmiastowe zastąpienie wszystkich, gdyż jest to szybsze.
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Zaktualizowanie instancji frontendowych
Testowanie witryny
-
Po uruchomieniu polecenia
rolling-action replace zaczekaj około
30 sekund na zakończenie przetwarzania instancji, a potem sprawdzaj stan
instancji w zarządzanej grupie instancji, dopóki instancje nie wyświetlą się
na liście:
watch -n 2 gcloud compute instance-groups list-instances fancy-fe-mig
-
Gdy instancje pojawią się na liście, zakończ polecenie watch,
naciskając Ctrl + C.
-
Uruchom to polecenie, by potwierdzić, że usługa jest sprawna (wyświetlony
zostanie ciąg znaków HEALTHY):
watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global
-
Zaczekaj, aż ciąg znaków HEALTHY będzie wyświetlany
w przypadku 2 usług.
Przykładowe dane wyjściowe:
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_region | "REGION" }}}/instanceGroups/fancy-fe-mig status: healthStatus:
- healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_region | "REGION" }}}/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080
- healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_region | "REGION" }}}/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth
Uwaga: jeśli w którejś instancji wystąpił problem i jest ona niesprawna (UNHEALTHY), powinna zostać automatycznie naprawiona. Zaczekaj, aż tak się stanie. Jeśli po krótkim czasie żadna instancja nie będzie sprawna (HEALTHY), oznacza to problem z konfiguracją instancji frontendowej, który uniemożliwia dostęp do niej przez port 8080. Przetestuj to, przechodząc do instancji bezpośrednio przez port 8080.
-
Gdy obie instancje będą wyświetlane na liście jako sprawne (HEALTHY),
zakończ polecenie
watch, naciskając CTRL+C.
Uwaga: aplikacja będzie dostępna pod adresem http://[LB_IP], gdzie [LB_IP] reprezentuje adres IP systemu równoważenia obciążenia, który możesz znaleźć za pomocą tego polecenia:
gcloud compute forwarding-rules list --global
Aplikację sprawdzisz w dalszej części tego laboratorium.
Zadanie 7. Skalowanie grup instancji Compute Engine
Jak dotąd utworzyliśmy 2 zarządzane grupy instancji zawierające po 2 instancje
każda. Ta konfiguracja jest w pełni funkcjonalna, jednak bez względu na
obciążenie jest konfiguracją statyczną. Teraz utworzysz zasadę autoskalowania
opartą na wykorzystaniu, która umożliwi automatyczne skalowanie każdej
zarządzanej grupy instancji.
Automatyczne zmienianie rozmiaru w zależności od wykorzystania
- Aby utworzyć zasadę autoskalowania, uruchom te polecenia:
gcloud compute instance-groups managed set-autoscaling \
fancy-fe-mig \
--max-num-replicas 2 \
--target-load-balancing-utilization 0.60
gcloud compute instance-groups managed set-autoscaling \
fancy-be-mig \
--max-num-replicas 2 \
--target-load-balancing-utilization 0.60
Polecenia te tworzą autoskalowanie w zarządzanych grupach instancji, które
automatycznie dodaje instancje, gdy wykorzystanie wzrasta powyżej 60%, i usuwa
je, gdy wykorzystanie systemu równoważenia obciążenia spada poniżej 60%.
Włączanie sieci dostarczania treści
Inną funkcją ułatwiającą skalowanie jest usługa sieci dostarczania treści,
która zapewnia buforowanie frontendu.
- Wykonaj to polecenie w usłudze frontendu:
gcloud compute backend-services update fancy-fe-frontend \
--enable-cdn --global
Gdy użytkownik wysyła żądanie treści z systemu równoważenia obciążenia
HTTP(S), żądanie to dociera do usługi Google Front End (GFE), która najpierw
szuka odpowiedzi na żądanie użytkownika w pamięci podręcznej usługi Cloud CDN.
Jeśli GFE znajdzie odpowiedź w pamięci podręcznej, wysyła ją do użytkownika.
Nazywa się to trafieniem w pamięci podręcznej.
Jeśli GFE nie może znaleźć odpowiedzi na żądanie w pamięci podręcznej, wysyła
żądanie bezpośrednio do backendu. Jeśli odpowiedź na to żądanie można umieścić
w pamięci podręcznej, GFE zapisuje odpowiedź w pamięci podręcznej usługi Cloud
CDN, by umożliwić jej użycie w kolejnych żądaniach.
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Skalowanie Compute Engine
Zadanie 8. Aktualizowanie witryny
Aktualizowanie szablonu instancji
Istniejących szablonów instancji nie można modyfikować. Ponieważ jednak
instancje są bezstanowe i cała konfiguracja jest zdefiniowana w skrypcie
startowym, aby zmienić ustawienia szablonu, wystarczy zmienić szablon
instancji. Wprowadzisz teraz prostą zmianę typu maszyny na większą i ją
zastosujesz.
-
Zaktualizuj instancję frontend, która jest podstawą szablonu
instancji. Podczas aktualizacji zapiszesz plik w zaktualizowanej wersji
obrazu szablonu instancji, a potem zaktualizujesz szablon instancji,
wdrożysz nowy szablon i sprawdzisz istnienie pliku w instancjach
zarządzanej grupy instancji.
-
Zmień teraz typ maszyny szablonu instancji z e2-medium na typ
niestandardowy z 4 procesorami wirtualnymi i 3840 MiB pamięci RAM.
-
Uruchom to polecenie, aby zmodyfikować typ maszyny instancji frontendowej:
gcloud compute instances set-machine-type frontend --machine-type custom-4-3840
- Utwórz nowy szablon instancji:
gcloud compute instance-templates create fancy-fe-new \
--source-instance=frontend \
--source-instance-zone={{{ project_0.default_zone | "ZONE" }}}
-
Wdróż zaktualizowany szablon instancji w zarządzanej grupie instancji:
gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
--version template=fancy-fe-new
-
Zaczekaj 30 sekund, a potem wykonaj to polecenie, aby monitorować stan
aktualizacji:
watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig
Zajmie to kilka chwil.
Gdy co najmniej 1 instancja znajdzie się w takim stanie:
- STATUS (Stan): RUNNING (Uruchomiona)
- ACTION (Działanie): None (Brak)
-
INSTANCE_TEMPLATE (Szablon instancji): nazwa nowego szablonu
(fancy-fe-new)
-
Skopiuj nazwę jednej z wymienionych maszyn, by jej użyć
w następnym poleceniu.
-
Naciśnij CTRL+C, by zakończyć proces watch.
-
Uruchom to polecenie, aby zobaczyć, czy maszyna wirtualna jest nowego typu
(custom-4-3840), gdzie [VM_NAME] to nowo utworzona instancja:
gcloud compute instances describe [VM_NAME] | grep machineType
Oczekiwane przykładowe dane wyjściowe:
machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/{{{ project_0.default_zone | "ZONE" }}}/machineTypes/custom-4-3840
Wprowadzanie zmian w witrynie
Scenariusz: dział marketingu poprosił o zmianę strony głównej
witryny. Ich zdaniem powinna zawierać więcej informacji o firmie i produktach,
które sprzedaje.
Zadanie: dodaj więcej tekstu do strony głównej, by spełnić
prośbę działu marketingu. Wygląda na to, że jeden z programistów przygotował
już odpowiednie zmiany i umieścił je w pliku o nazwie
index.js.new. Wystarczy skopiować ten plik do
index.js, a zmiany zostaną zastosowane automatycznie. Wykonaj
poniższe instrukcje, by wprowadzić odpowiednie zmiany.
-
Uruchom te polecenia, aby skopiować zaktualizowany plik z poprawną nazwą:
cd ~/monolith-to-microservices/react-app/src/pages/Home
mv index.js.new index.js
- Wyświetl treść pliku, by sprawdzić wprowadzone zmiany:
cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js
Wynikowy kod powinien wyglądać podobnie do tego:
/*
Copyright 2019 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import React from "react";
import { Box, Paper, Typography } from "@mui/material";
export default function Home() {
return (
theme.spacing(3, 2),
}}
>
Fancy Fashion & Style Online
Tired of mainstream fashion ideas, popular trends and societal norms? This
line of lifestyle products will help you catch up with the Fancy
trend and express your personal style. Start shopping Fancy items
now!
);
}
Zaktualizowane zostały komponenty React, ale musisz jeszcze utworzyć aplikację
React, by wygenerować pliki statyczne.
-
Uruchom to polecenie, by utworzyć aplikację React i skopiować ją do katalogu
publicznego usługi monolith:
cd ~/monolith-to-microservices/react-app
npm install && npm run-script build
- Potem ponownie umieść kod w zasobniku:
cd ~
rm -rf monolith-to-microservices/*/node_modules
gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | BUCKET}}}/
Wypychanie zmian z zastąpieniami kroczącymi
-
Wymuś teraz zastąpienie wszystkich instancji, aby pobrać aktualizację:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \
--max-unavailable=100%
Uwaga: w tym przykładzie zastąpień kroczących za pomocą parametru --max-unavailable wskazujesz, że wszystkie maszyny można zastąpić natychmiast. Gdyby nie było tego parametru, polecenie zachowałoby aktywną instancję podczas zastępowania innych.
Dla celów testowych określa się natychmiastowe zastąpienie wszystkich, gdyż jest to szybsze. W środowisku produkcyjnym pozostawienie bufora umożliwiłoby ciągłe działanie witryny podczas jej aktualizowania.
Kliknij Sprawdź postępy, aby zobaczyć, jak Ci poszło.
Zaktualizowanie witryny
-
Po uruchomieniu polecenia
rolling-action replace zaczekaj około
30 sekund na zakończenie przetwarzania instancji, a potem sprawdzaj stan
instancji w zarządzanej grupie instancji, dopóki instancje nie wyświetlą się
na liście:
watch -n 2 gcloud compute instance-groups list-instances fancy-fe-mig
-
Gdy instancje pojawią się na liście, zakończ polecenie watch,
naciskając Ctrl + C.
-
Uruchom to polecenie, by potwierdzić, że usługa jest sprawna (wyświetlony
zostanie ciąg znaków HEALTHY):
watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global
- Zaczekaj chwilę, aż obie usługi pojawią się i będą sprawne (HEALTHY).
Przykładowe dane wyjściowe:
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instanceGroups/fancy-fe-mig status: healthStatus:
- healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080
- healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth
-
Gdy instancje pojawią się na liście, zakończ polecenie watch,
naciskając Ctrl + C.
-
Otwórz witrynę dostępną pod adresem http://[LB_IP], gdzie
[LB_IP] reprezentuje adres IP systemu równoważenia
obciążenia, który możesz znaleźć za pomocą tego polecenia:
gcloud compute forwarding-rules list --global
Nowe zmiany w witrynie powinny być teraz widoczne.
Symulacja uszkodzenia
Aby potwierdzić działanie kontroli stanu, zaloguj się w instancji i zatrzymaj
usługi.
- Wykonaj to polecenie, by znaleźć nazwę instancji:
gcloud compute instance-groups list-instances fancy-fe-mig
-
Skopiuj nazwę instancji, a potem uruchom bezpieczną powłokę w instancji za
pomocą poniższego polecenia, w którym
[INSTANCE_NAME] jest
nazwą jednej z instancji z listy:
gcloud compute ssh [INSTANCE_NAME]
-
Wpisz Y, aby potwierdzić, i dwukrotnie naciśnij
Enter, aby nie używać hasła.
-
Będąc w instancji, zatrzymaj aplikację za pomocą polecenia
supervisorctl:
sudo supervisorctl stop nodeapp; sudo killall node
- Opuść instancję:
exit
- Monitoruj operacje naprawy:
watch -n 2 gcloud compute operations list \
--filter='operationType~compute.instances.repair.*'
Potrwa to kilka minut.
Szukaj danych wyjściowych podobnych do poniższych przykładowych:
NAME TYPE TARGET HTTP_STATUS STATUS TIMESTAMP
repair-1568314034627-5925f90ee238d-fe645bf0-7becce15 compute.instances.repair.recreateInstance {{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-1vqq 200 DONE 2019-09-12T11:47:14.627-07:00
Zarządzana grupa instancji odtworzyła instancję, aby ją naprawić.
-
Możesz też monitorować te operacje za pomocą konsoli. W tym celu otwórz
Menu nawigacyjne > Compute Engine >
Instancje maszyn wirtualnych.
Gratulacje!
Gratulacje! W tym laboratorium udało Ci się wdrożyć, przeskalować
i zaktualizować witrynę w Compute Engine. Pozwoliło Ci to zdobyć praktyczne
doświadczenie w zakresie używania Compute Engine, zarządzanych grup instancji,
systemów równoważenia obciążenia i kontroli stanu. To laboratorium pokazuje,
jak Google Cloud i Azure ułatwiają wdrażanie aplikacji opartych na maszynach
wirtualnych przy użyciu modułów równoważenia obciążenia dostępnych z
internetu. Podejście Google Cloud wykorzystuje skrypty startowe do
ujednolicania wdrażania kodu i konfiguracji maszyn wirtualnych, usprawnia
zarządzanie maszynami wirtualnymi dzięki autoskalowaniu, zapewnia globalne
zewnętrzne równoważenie obciążenia HTTP(S) i umożliwia bezproblemowe
aktualizowanie obrazów i aplikacji w ramach przepływu pracy z użyciem skryptów
startowych i zarządzanych grup instancji.
Poniżej znajdziesz podsumowanie podobieństw i różnic między tymi
2 platformami, które pojawiły się w tym laboratorium.
Podobieństwa:
-
Google Cloud, podobnie jak Azure, umożliwia wdrażanie aplikacji na maszynach
wirtualnych i konfigurowanie systemów równoważenia obciążenia w celu
udostępniania aplikacji w internecie.
Różnice:
-
W Google Cloud wdrożenie usługi aplikacji odbyło się za pomocą Compute
Engine z kodu hostowanego w zasobniku Cloud Storage. W Azure musisz użyć
potoku DevOps lub repozytorium kodu, aby uzyskać taki sam rezultat.
-
W Google Cloud zarządzasz wdrażaniem kodu, konfiguracją maszyn wirtualnych
i aktualizacją aplikacji za pomocą tego samego skryptu startowego. W Azure
musisz zarządzać wdrażaniem kodu z potoków DevOps lub repozytorium kodu,
a osobno zarządzać maszynami wirtualnymi za pomocą zestawów skalowania.
-
W Google Cloud możesz zaktualizować kod aplikacji i ponownie ją wdrożyć za
pomocą modelu wdrożenia kroczącego bez przestojów. W Azure do aktualizacji
używany jest okres konserwacji.
-
W Google Cloud możesz włączyć autoskalowanie w zarządzanych grupach
instancji (MIG). Poza tym Google Cloud obsługuje i aktualizuje maszyny
wirtualne w grupach instancji. W Azure używane są zestawy skalowania.
Kolejne kroki / Więcej informacji
Szkolenia i certyfikaty Google Cloud
…pomogą Ci wykorzystać wszystkie możliwości technologii Google Cloud. Nasze zajęcia obejmują umiejętności techniczne oraz sprawdzone metody, które ułatwią Ci szybką naukę i umożliwią jej kontynuację. Oferujemy szkolenia na poziomach od podstawowego po zaawansowany prowadzone w trybach wirtualnym, na żądanie i na żywo, dzięki czemu możesz dopasować program szkoleń do swojego napiętego harmonogramu. Certyfikaty umożliwią udokumentowanie i potwierdzenie Twoich umiejętności oraz doświadczenia w zakresie technologii Google Cloud.
Ostatnia aktualizacja instrukcji: 4 sierpnia 2026 r.
Ostatni test laboratorium: 4 sierpnia 2026 r.
Copyright 2026 Google LLC. Wszelkie prawa zastrzeżone. Google i logo Google są znakami towarowymi Google LLC. Wszelkie inne nazwy firm i produktów mogą być znakami towarowymi odpowiednich podmiotów, z którymi są powiązane.