GSP662

Opis

Jest wiele sposobów wdrażania witryn internetowych w Google Cloud. Każde z tych rozwiązań oferuje inne funkcje, możliwości i poziomy kontroli. Compute Engine zapewnia szczegółową kontrolę nad infrastrukturą, w której działa witryna, ale jednocześnie ma trochę większe wymagania w zakresie zarządzania operacyjnego w porównaniu z takimi rozwiązaniami, jak Google Kubernetes Engine (GKE), App Engine i inne. Compute Engine daje Ci pełną kontrolę nad wieloma aspektami infrastruktury, w tym maszynami wirtualnymi, systemami równoważenia obciążenia i nie tylko.

W tym module dowiesz się, jak wdrożyć przykładową aplikację sklepu internetowego „Fancy Store”. Przekonasz się, jak łatwo jest wdrażać i skalować strony internetowe za pomocą Compute Engine.

Czego się nauczysz

Z tego modułu nauczysz się, jak:

• tworzyć instancje Compute Engine,
• tworzyć szablony instancji z instancji źródłowych,
• tworzyć zarządzane grupy instancji,
• tworzyć i testować kontrole stanu zarządzanych grup instancji,
• tworzyć systemy równoważenia obciążenia HTTP(S),
• tworzyć kontrole stanu systemu równoważenia obciążenia,
• używać sieci dostarczania treści (CDN) do buforowania.

Na koniec modułu 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 modułu i logowanie się w konsoli Google Cloud

1. Kliknij przycisk Rozpocznij moduł. Jeśli moduł jest odpłatny, otworzy się okno, w którym możesz wybrać formę płatności. Po lewej stronie znajduje się panel Szczegóły modułu z następującymi elementami:

   • przyciskiem Otwórz konsolę Google Cloud;
   • czasem, który Ci pozostał;
   • tymczasowymi danymi logowania, których musisz użyć w tym module;
   • innymi informacjami potrzebnymi do ukończenia modułu.

2. Kliknij Otwórz konsolę Google Cloud (lub kliknij prawym przyciskiem myszy i wybierz Otwórz link w oknie incognito, jeśli korzystasz z przeglądarki Chrome).

   Moduł uruchomi zasoby, po czym otworzy nową kartę ze stroną logowania.

   Wskazówka: otwórz karty obok siebie w osobnych oknach.

   Uwaga: jeśli pojawi się okno Wybierz konto, kliknij Użyj innego konta.

3. 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 Szczegóły modułu.

4. Kliknij Dalej.

5. Skopiuj podane niżej hasło i wklej je w oknie powitania.

   {{{user_0.password | "Password"}}}

   Hasło znajdziesz też w panelu Szczegóły modułu.

6. Kliknij Dalej.

   Ważne: musisz użyć danych logowania podanych w module. Nie używaj danych logowania na swoje konto Google Cloud. Uwaga: korzystanie z własnego konta Google Cloud w tym module może wiązać się z dodatkowymi opłatami.

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

1. Kliknij Aktywuj Cloud Shell  na górze konsoli Google Cloud.

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

3. (Opcjonalnie) Aby wyświetlić listę aktywnych kont, użyj tego polecenia:

gcloud auth list

4. Kliknij Autoryzuj.

Dane wyjściowe:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (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 regionu i strefy

Niektóre zasoby Compute Engine znajdują się w regionach i strefach. Region to określona lokalizacja geograficzna, w której możesz uruchomić swoje zasoby. Każdy region zawiera co najmniej 1 strefę.

Aby ustawić domyślny region i strefę dla Twojego modułu, uruchom te polecenia gcloud w Cloud Shell:

gcloud config set compute/zone "{{{project_0.default_zone|ZONE}}}" export ZONE=$(gcloud config get compute/zone) gcloud config set compute/region "{{{project_0.default_region|REGION}}}" export REGION=$(gcloud config get compute/region)

Zadanie 1. Włączanie interfejsu Compute Engine API

• Włącz Compute Engine API, wykonując to polecenie:

gcloud services enable compute.googleapis.com

Zadanie 2. Tworzenie zasobnika Cloud Storage

W zasobniku Cloud Storage będziesz przechowywać utworzony kod oraz skrypty startowe.

• Wykonaj w Cloud Shell to polecenie, aby utworzyć nowy zasobnik Cloud Storage:

gsutil mb gs://fancy-store-{{{project_0.project_id | Project ID}}}

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 modułu przeprowadzisz niewielką aktualizację kodu, która pokaże, jak proste jest aktualizowanie w Compute Engine.

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

2. Wykonaj początkową kompilację kodu, by umożliwić lokalne uruchamianie aplikacji, uruchamiając poniższy skrypt:

./setup.sh

Wykonanie tego skryptu zajmie kilka minut.

3. Gdy się zakończy, sprawdź, czy w Cloud Shell uruchomiona jest zgodna wersja nodeJS. Użyj tego polecenia:

nvm install --lts

4. Następnie uruchom poniższe polecenie, by przetestować aplikację, przejść do katalogu microservices i uruchomić serwer WWW:

cd microservices npm start

Powinny pojawić się te wyniki.

Dane wyjściowe:

Products microservice listening on port 8082! Frontend microservice listening on port 8080! Orders microservice listening on port 8081!

5. Wyświetl podgląd swojej aplikacji, klikając ikonę podglądu w przeglądarce i wybierając Podejrzyj na porcie 8080.

Otworzy się nowe okno, w którym zobaczysz frontend sklepu Fancy Store.

Uwaga: po wybraniu opcji podglądu powinien być widoczny frontend. Funkcje produktów i zamówień nie będą jednak działać, ponieważ te usługi nie zostały jeszcze udostępnione.

6. Po przejrzeniu strony internetowej zamknij to okno i naciśnij CTRL+C w oknie terminala, by zatrzymać proces serwera WWW.

Włączanie Gemini Code Assist w środowisku IDE Cloud Shell

Możesz używać Gemini Code Assist w zintegrowanym środowisku programistycznym (IDE) takim jak Cloud Shell, aby otrzymywać wskazówki dotyczące kodu lub rozwiązywać problemy z kodem. Zanim zaczniesz korzystać z Gemini Code Assist, musisz tę usługę włączyć.

1. W Cloud Shell za pomocą tego polecenia włącz Gemini for Google Cloud API:

gcloud services enable cloudaicompanion.googleapis.com

2. Na pasku narzędzi Cloud Shell kliknij Otwórz edytor.

Uwaga: aby otworzyć edytor Cloud Shell, na pasku narzędzi Cloud Shell kliknij Otwórz edytor. Możesz przełączać się między Cloud Shell a edytorem kodu, klikając w razie potrzeby Otwórz edytor lub Otwórz terminal.

3. W panelu po lewej stronie kliknij ikonę Ustawienia, a następnie w widoku Ustawienia wyszukaj Gemini Code Assist.

4. Znajdź i zaznacz pole wyboru Geminicodeassist: Enable, a następnie zamknij Ustawienia.

5. Na pasku stanu u dołu ekranu kliknij Cloud Code – brak projektu.

6. Autoryzuj wtyczkę zgodnie z instrukcjami. Jeśli projekt nie zostanie wybrany automatycznie, kliknij Wybierz projekt Google Cloud i wybierz .

7. Sprawdź, czy Twój projekt Google Cloud () wyświetla się w komunikacie o stanie Cloud Code na pasku stanu.

Zadanie 4. Tworzenie instancji Compute Engine

Teraz kolej na rozpoczęcie wdrażania instancji Compute Engine.

W kolejnych sekcjach wykonasz te czynności:

1. Utworzysz skrypt startowy służący do konfigurowania instancji.
2. Sklonujesz kod źródłowy i prześlesz go do Cloud Storage.
3. Wdrożysz instancję Compute Engine, która będzie hostować mikroserwisy backendu.
4. Ponownie skonfigurujesz kod frontendu w sposób umożliwiający korzystanie z instancji mikroserwisów backendu.
5. Wdrożysz instancję Compute Engine, która będzie hostować mikroserwis frontendu.
6. 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. Pozwala to na automatyczne konfigurowanie instancji.

1. Uruchom w terminalu Cloud Shell to polecenie, by utworzyć plik o nazwie startup-script.sh:

touch ~/monolith-to-microservices/startup-script.sh

2. Na pasku narzędzi Cloud Shell kliknij Otwórz edytor, aby otworzyć edytor kodu.

3. Przejdź do folderu monolith-to-microservices.

4. Dodaj poniższy kod do pliku startup-script.sh. Po jego dodaniu wprowadzisz pewne modyfikacje:

#!/bin/bash # Install logging monitor. The monitor will automatically pick up logs sent to # syslog. curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash service google-fluentd restart & # Install dependencies from apt apt-get update apt-get install -yq ca-certificates git build-essential supervisor psmisc # Install nodejs mkdir /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 -s /opt/nodejs/bin/node /usr/bin/node ln -s /opt/nodejs/bin/npm /usr/bin/npm # Get the application source code from the Google Cloud Storage bucket. mkdir /fancy-store gsutil -m cp -r gs://fancy-store-[DEVSHELL_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. useradd -m -d /home/nodeapp nodeapp chown -R nodeapp:nodeapp /opt/app # 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

5. Aby zaktualizować plik startup-script.sh, kliknij ikonę Gemini Code Assist: inteligentne działania  i wklej poniższy tekst w prompcie, by znaleźć i zastąpić tekst [DEVSHELL_PROJECT_ID].

Jako programista aplikacji w firmie Cymbal AI zaktualizuj plik „startup-script.sh”. Zastąp [DEVSHELL_PROJECT_ID] identyfikatorem projektu: {{{project_0.project_id | Project ID}}}.

6. Naciśnij Enter, aby zaktualizować plik. Gdy pojawi się odpowiedni komunikat w widoku Gemini Diff, kliknij Akceptuj.

Wiersz kodu w pliku startup-script.sh powinien wyglądać teraz tak:

gs://fancy-store-{{{project_0.project_id | Project ID}}}/monolith-to-microservices/microservices/* /fancy-store/

7. Kliknij Zapisz lub naciśnij CTRL+S, aby zapisać plik startup-script.sh, ale jeszcze go nie zamykaj.

8. Sprawdź, czy w prawym dolnym rogu edytora kodu Cloud Shell opcja „End of Line Sequence” jest ustawiona na „LF”, a nie „CRLF”.

• Jeśli zobaczysz ustawienie CRLF, kliknij CRLF i wybierz LF z listy rozwijanej.
• Jeśli zobaczysz ustawienie LF, pozostaw je bez zmian.

Uzyskiwanie dodatkowych informacji o pliku skryptu startowego za pomocą Gemini Code Assist

Aby zwiększyć Twoją produktywność i ograniczyć przełączanie kontekstu, Gemini Code Assist udostępnia inteligentne działania oparte na AI bezpośrednio w edytorze kodu. Możesz na przykład użyć funkcji „Wyjaśnij”, aby Gemini Code Assist dostarczył Ci więcej informacji o danym pliku, bloku kodu lub funkcji.

W tej sekcji poprosisz Gemini Code Assist o podanie dodatkowych informacji o skrypcie startowym dla nowego członka zespołu, który nie zna tego skryptu.

1. Gdy plik startup-script.sh jest otwarty, kliknij ikonę Gemini Code Assist: inteligentne działania  na pasku narzędzi i wybierz Wyjaśnij.

2. Gemini Code Assist otworzy panel czatu z wstępnie wypełnionym promptem Explain this. W polu tekstowym na czacie Code Assist zastąp wstępnie wypełniony prompt poniższym tekstem i kliknij Wyślij:

Jesteś programistą aplikacji w firmie Cymbal AI. Nowy członek zespołu nie zna tego skryptu startowego. Szczegółowo opisz plik „startup-script.sh”, rozkładając na czynniki pierwsze jego kluczowe komponenty użyte w kodzie. Nie sugeruj żadnych ulepszeń ani zmian w pliku.

Wyjaśnienie kodu w pliku startup-script.sh pojawi się na czacie Gemini Code Assist.

3. Zamknij plik startup-script.sh.

Wróć do terminala Cloud Shell i wykonaj to polecenie, by skopiować plik startup-script.sh do swojego zasobnika:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-{{{project_0.project_id | Project ID}}}

Będzie on teraz dostępny w: https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh.

[BUCKET_NAME] reprezentuje nazwę zasobnika Cloud Storage. Domyślnie jest widoczny tylko dla autoryzowanych użytkowników i kont usługi, a więc nie jest dostępny w przeglądarce. Instancje Compute Engine automatycznie mają do niego dostęp za pośrednictwem swoich kont usługi.

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.
• Klonuje 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 stdout i stderr do syslog, by umożliwić ich zbieranie przez agenta logowania.

Kopiowanie kodu do zasobnika Cloud Storage

Gdy instancje się uruchamiają, 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. Jednak 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.

• Uruchom to polecenie, aby skopiować sklonowany kod do swojego zasobnika:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/ 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, by utworzyć instancję e2-standard-2 skonfigurowaną do korzystania ze skryptu startowego. Jest ona oznaczona tagiem jako instancja backend, aby można było do niej później zastosować konkretne reguły zapory sieciowej:

gcloud compute instances create backend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh

Konfigurowanie połączenia z backendem

Przed wdrożeniem frontendu aplikacji musisz zaktualizować konfigurację, wskazując w niej wdrożony przed chwilą backend.

1. 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: backend ZONE: {{{project_0.default_zone | zone}}} MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.142.0.2 EXTERNAL_IP: 35.237.245.193 STATUS: RUNNING

2. Skopiuj zewnętrzny adres IP backendu.

3. W eksploratorze Cloud Shell przejdź do folderu monolith-to-microservices > react-app.

4. W edytorze kodu wybierz View > Toggle Hidden Files, aby wyświetlić plik .env.

W następnym kroku zmodyfikujesz plik .env, by wskazywał zewnętrzny adres IP backendu. [BACKEND_ADDRESS] reprezentuje zewnętrzny adres IP instancji backendowej ustalony na podstawie ostatnio wykonanego polecenia gcloud.

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

6. Zapisz plik.

7. Wykonaj w Cloud Shell 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

8. Następnie uruchom to polecenie, aby skopiować kod aplikacji do zasobnika Cloud Storage:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

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 \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=frontend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh Uwaga: polecenie wdrażania i skrypt startowy są używane w przypadku instancji frontendowej oraz backendowej dla uproszczenia, a także ze względu na to, że w kodzie skonfigurowano domyślnie uruchamianie 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

1. Uruchom poniższe polecenie, aby utworzyć 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 tych poleceniach związanych z zaporami sieciowymi używane są tagi przypisane podczas tworzenia instancji dla aplikacji:

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.

2. 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: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.2 EXTERNAL_IP: 34.27.178.79 STATUS: RUNNING NAME: frontend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.3 EXTERNAL_IP: 34.172.241.242 STATUS: RUNNING

Uruchomienie i skonfigurowanie instancji może potrwać kilka minut.

3. Odczekaj 3 minuty, a następnie 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 wcześniej określony zewnętrzny adres IP frontendu.

4. 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 (MIG) 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. 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.

1. Najpierw uruchom to polecenie, aby zatrzymać obie instancje:

gcloud compute instances stop frontend --zone={{{project_0.default_zone | zone}}} gcloud compute instances stop backend --zone={{{project_0.default_zone | zone}}}

2. Następnie utwórz szablon instancji na podstawie każdej z instancji źródłowych za pomocą tych poleceń:

gcloud compute instance-templates create fancy-fe \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=backend

3. Uruchom to polecenie, aby sprawdzić, czy szablony instancji zostały utworzone:

gcloud compute instance-templates list

Przykładowe dane wyjściowe:

NAME: fancy-be MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:21.933-07:00 NAME: fancy-fe MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:15.442-07:00

4. 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 --zone={{{project_0.default_zone | zone}}}

5. Wpisz y, gdy pojawi się prośba.

Normalnie można by też usunąć maszynę wirtualną frontend, ale będziesz jej potrzebować do zaktualizowania szablonu instancji w dalszej części modułu.

Tworzenie zarządzanych grup instancji

1. 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 \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --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.

2. Uruchom poniższe polecenia, aby sprawdzić, czy 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 \ --zone={{{project_0.default_zone | zone}}} \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --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 instancji, co jest działaniem 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. Kontrola stanu związana z automatyczną naprawą powoduje natomiast, że Compute Engine aktywnie zastępuje uszkodzone instancje. Z tego względu powinna być bardziej restrykcyjna niż w przypadku równoważenia obciążenia.

1. Uruchom poniższe polecenie, aby utworzyć kontrolę stanu, która naprawi instancję, jeśli 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

2. Uruchom poniższe polecenie, aby utworzyć regułę zapory sieciowej, która umożliwia sondom kontroli stanu nawiązywanie 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

3. Zastosuj kontrole stanu do odpowiednich usług za pomocą tych poleceń:

gcloud compute instance-groups managed update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-be-hc \ --initial-delay 300 Uwaga: może upłynąć 15 minut, zanim automatyczna naprawa zacznie monitorować instancje w grupie.

4. Kontynuuj moduł, by dać funkcji automatycznej naprawy dość czasu na rozpoczęcie monitorowania instancji w grupie. Aby przetestować automatyczną naprawę, na końcu modułu przeprowadzisz symulację awarii.

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 uzupełnisz 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 Omówienie równoważenia 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 module do obsługi ruchu użyjesz 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.

1. Uruchom następujące polecenia, aby utworzyć kontrole stanu, które będą używane do określania instancji mogących obsłużyć ruch do poszczególnych usług:

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 tego systemu. Nie zapewniają odtwarzania instancji w zarządzanych grupach instancji.

2. Uruchom następujące polecenia, aby utworzyć docelowe usługi backendu dla ruchu z systemu równoważenia obciążenia. Usługi backendu będą 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

3. Uruchom te polecenia, aby dodać usługi backendu systemu równoważenia obciążenia:

gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global

4. Uruchom to polecenie, aby utworzyć mapę URL, która określa, które adresy URL mają być kierowane do których usług backendu:

gcloud compute url-maps create fancy-map \ --default-service fancy-fe-frontend

5. Uruchom to polecenie, aby utworzyć dopasowanie ścieżek, które umożliwia 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"

6. Uruchom to polecenie, aby utworzyć serwer proxy, który wiąże z mapą URL:

gcloud compute target-http-proxies create fancy-proxy \ --url-map fancy-map

7. Uruchom to polecenie, aby utworzyć 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.

1. W Cloud Shell wykonaj to polecenie, aby przejść do folderu react-app, w którym znajduje się plik .env zawierający konfigurację:

cd ~/monolith-to-microservices/react-app/

2. Znajdź adres IP systemu równoważenia obciążenia, uruchamiając to polecenie:

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

3. Wróć do edytora Cloud Shell i ponownie zmodyfikuj plik .env tak, by wskazywał publiczny adres IP systemu równoważenia obciążenia. Ciąg znaków [LB_IP] reprezentuje określony wcześniej zewnętrzny adres IP instancji backendowej.

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.

4. Zapisz plik.

5. Uruchom te polecenia, aby ponownie utworzyć aplikację react-app, co spowoduje zaktualizowanie kodu frontendu:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build

6. Uruchom to polecenie, aby skopiować kod aplikacji do zasobnika:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

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, uruchom następujące polecenie kroczącego restartu:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-unavailable 100% Uwaga: w tym przykładzie zastąpień kroczących za pomocą parametru --max-unavailable wyraźnie stwierdza się, że wszystkie maszyny można zastąpić natychmiast. Gdyby nie było tego parametru, polecenie zachowałoby aktywną instancję podczas restartowania innych, 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

1. Po uruchomieniu polecenia rolling-action replace zaczekaj 3 minuty na zakończenie przetwarzania instancji, a potem sprawdź stan zarządzanej grupy instancji. 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

2. 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/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/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/us-central1-a/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 (ciąg znaków UNHEALTHY), powinna zostać automatycznie naprawiona. Zaczekaj, aż tak się stanie.

Jeśli po odczekaniu krótkiego czasu żadna instancja nie będzie sprawna (HEALTHY), oznacza to problem z konfiguracją instancji frontendowych, który uniemożliwia dostęp do nich przez port 8080. Przetestuj to, przechodząc do instancji bezpośrednio przez port 8080.

3. 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 modułu.

Zadanie 7. Skalowanie 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 jest konfiguracją statyczną, niezależnie od obciążenia. Teraz utworzymy 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 \ --zone={{{project_0.default_zone | zone}}} \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --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. W tym zadaniu wprowadzisz prostą zmianę typu maszyny na większą i ją zastosujesz.

Wykonaj poniższe kroki, aby wykonać te działania:

• Zaktualizuj instancję frontend, która jest podstawą szablonu instancji. Podczas aktualizacji zapisz plik w zaktualizowanej wersji obrazu szablonu instancji, a potem zaktualizuj szablon instancji, wdróż nowy szablon i sprawdź istnienie pliku w instancjach zarządzanej grupy instancji.

• Zmodyfikuj typ maszyny szablonu instancji, zmieniając go z e2-standard-2 na e2-small.

1. Uruchom to polecenie, aby zmodyfikować typ maszyny instancji frontendowej:

gcloud compute instances set-machine-type frontend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type e2-small

2. Uruchom to polecenie, aby utworzyć nowy szablon instancji:

gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone={{{project_0.default_zone | zone}}}

3. Wdróż zaktualizowany szablon instancji w zarządzanej grupie instancji za pomocą tego polecenia:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --version template=fancy-fe-new

4. Zaczekaj 3 minuty, a potem wykonaj to polecenie, aby monitorować stan aktualizacji:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}}

Ten proces trwa kilka minut.

Zanim przejdziesz dalej, upewnij się, że masz co najmniej 1 instancję w takim stanie:

• STATUS (Stan): RUNNING (Uruchomiona)
• ACTION (Działanie): None (Brak)
• INSTANCE_TEMPLATE (Szablon instancji): nazwa nowego szablonu (fancy-fe-new)

5. Skopiuj nazwę jednej z wymienionych maszyn, by jej użyć w następnym poleceniu.

6. Naciśnij CTRL+C, by zakończyć proces watch.

7. Uruchom to polecenie, by zobaczyć, czy maszyna wirtualna jest nowego typu (e2-small), gdzie [VM_NAME] to nowo utworzona instancja:

gcloud compute instances describe [VM_NAME] --zone={{{project_0.default_zone | zone}}} | grep machineType

Oczekiwane przykładowe dane wyjściowe:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/e2-small

Wprowadzanie zmian w witrynie

Scenariusz: dział marketingu poprosił o zmianę strony głównej witryny. Ich zdaniem powinna ona lepiej przedstawiać firmę i produkty, które sprzedaje.

W tej sekcji dodasz więcej tekstu do strony głównej, aby 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ą automatycznie zastosowane. Wykonaj poniższe instrukcje, by wprowadzić odpowiednie zmiany.

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

2. 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:

Dane wyjściowe:

/* 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 ( <Box sx={{ flexGrow: 1 }}> <Paper elevation={3} sx={{ width: "800px", margin: "0 auto", padding: (theme) => theme.spacing(3, 2), }} > <Typography variant="h5">Witamy w sklepie Fancy Store!</Typography> <br /> <Typography variant="body1"> Zapoznaj się z naszą szeroką gamą produktów. </Typography> </Paper> </Box> ); }

Komponenty React zostały zaktualizowane, ale musisz jeszcze utworzyć aplikację React, by wygenerować pliki statyczne.

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

4. Następnie uruchom to polecenie, aby ponownie umieścić kod w zasobniku:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Wypychanie zmian z zastąpieniami kroczącymi

1. Uruchom teraz to polecenie, aby wymusić zastąpienie wszystkich instancji i pobrać aktualizację:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-unavailable=100%

Uwaga: w tym przykładzie kroczącego zastąpienia za pomocą parametru --max-unavailable wyraźnie stwierdza się, ż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

2. Po uruchomieniu polecenia rolling-action replace zaczekaj 3 minuty na zakończenie przetwarzania instancji, a potem sprawdź stan zarządzanej grupy instancji. 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

3. 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/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/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/us-central1-a/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth

4. Gdy instancje pojawią się na liście ze stanem HEALTHY, zakończ polecenie watch, naciskając CTRL+C.

5. 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 awarii

Aby potwierdzić działanie kontroli stanu, zaloguj się w instancji i zatrzymaj usługi.

1. Wykonaj to polecenie, by znaleźć nazwę instancji:

gcloud compute instance-groups list-instances fancy-fe-mig --zone={{{project_0.default_zone | zone}}}

2. Skopiuj nazwę instancji, a potem uruchom SSH w instancji za pomocą poniższego polecenia, w którym [INSTANCE_NAME] jest nazwą jednej z instancji z listy:

gcloud compute ssh [INSTANCE_NAME] --zone={{{project_0.default_zone | zone}}}

3. Wpisz „y”, aby potwierdzić, i dwukrotnie naciśnij klawisz Enter, by nie używać hasła.

4. Będąc w instancji, uruchom to polecenie, aby zatrzymać aplikację za pomocą polecenia supervisorctl:

sudo supervisorctl stop nodeapp; sudo killall node

5. Aby opuścić instancję, uruchom to polecenie:

exit

6. Monitoruj operacje naprawy:

watch -n 2 gcloud compute operations list \ --filter='operationType~compute.instances.repair.*'

Ten proces trwa kilka minut.

Szukaj danych wyjściowych podobnych do poniższych przykładowych:

Dane wyjściowe:

NAME: repair-1755080598062-63c3c8b99843b-eed8dabc-f1833ea3 TYPE: compute.instances.repair.recreateInstance TARGET: us-east4-c/instances/fancy-fe-tn40 HTTP_STATUS: 200 STATUS: DONE TIMESTAMP: 2025-08-13T03:23:18.062-07:00

Zarządzana grupa instancji odtworzyła instancję, aby ją naprawić.

7. Możesz też otworzyć Menu nawigacyjne > Compute Engine > Instancje maszyn wirtualnych, aby monitorować dane w konsoli.

Gratulacje!

Udało Ci się wdrożyć, przeskalować i zaktualizować witrynę w Compute Engine. Wiesz już, co to jest Compute Engine i na czym polega działanie zarządzanych grup instancji, systemów równoważenia obciążenia oraz kontroli stanu.

Kolejne kroki / Więcej informacji

• Automatyczna naprawa i kontrole stanu w zarządzanych grupach instancji

• Film ze studium przypadku na temat hostowania skalowalnych aplikacji internetowych w Google Cloud

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: 25 sierpnia 2025 r.

Ostatni test modułu: 25 sierpnia 2025 r.

Copyright 2025 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.