1. Wprowadzenie
Istnieje wiele sposobów wdrażania witryn w Google Cloud, a 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, App Engine i inne. Compute Engine daje Ci pełną kontrolę nad wieloma aspektami infrastruktury, w tym maszynami wirtualnymi, systemem równoważenia obciążenia i nie tylko. Dziś wdrożysz 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
- Jak tworzyć instancje Compute Engine
- Jak tworzyć szablony instancji z instancji źródłowych
- Jak tworzyć zarządzane grupy instancji
- Jak skonfigurować kontrole stanu i automatyczną naprawę
- Jak tworzyć równoważenie obciążenia HTTP(S)
- Jak tworzyć kontrole stanu systemów równoważenia obciążenia
- Jak używać sieci dostarczania treści do buforowania
Na końcu tego modułu będziesz mieć instancje w zarządzanych grupach instancji, dzięki czemu w Twojej witrynie obsługiwane będą funkcje automatycznej naprawy, równoważenia obciążenia, autoskalowania i aktualizacji kroczących.
Wymagania wstępne
- Aby zapoznać się z koncepcjami, których będziemy używać w tym module, przeczytaj poniższe materiały:
- Witamy w Google Cloud Platform – podstawy GCP
- Wprowadzenie do Google Cloud Compute Engine
- Pierwsze kroki z Google Cloud Storage
- Wprowadzenie: Cloud Shell
2. Konfigurowanie środowiska
Samodzielne konfigurowanie środowiska
- Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.
Zapamiętaj identyfikator projektu, czyli unikalną nazwę we wszystkich projektach Google Cloud (podana powyżej nazwa jest już zajęta i nie będzie działać w Twoim przypadku). W dalszej części tego laboratorium będzie on nazywany PROJECT_ID.
- Następnie musisz włączyć rozliczenia w konsoli Cloud, aby korzystać z zasobów Google Cloud.
Ukończenie tego laboratorium nie powinno wiązać się z dużymi kosztami, a nawet z żadnymi. Wykonaj instrukcje z sekcji „Czyszczenie”, w której znajdziesz informacje o tym, jak wyłączyć zasoby, aby uniknąć naliczenia opłat po zakończeniu tego samouczka. Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.
Włączanie interfejsu Compute Engine API
Następnie musisz włączyć interfejs Compute Engine API. Włączenie interfejsu API wymaga zaakceptowania warunków korzystania z usługi i odpowiedzialności za rozliczenia związane z interfejsem API.
Aby włączyć interfejs Compute Engine API, w Cloud Shell wykonaj to polecenie:
gcloud services enable compute.googleapis.com
Cloud Shell
Z Google Cloud możesz korzystać zdalnie na laptopie, ale w tym module użyjesz Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.
Ta maszyna wirtualna oparta na Debianie zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Oznacza to, że do ukończenia tego ćwiczenia potrzebujesz tylko przeglądarki (działa ona na Chromebooku).
- Aby aktywować Cloud Shell w konsoli Cloud, kliknij Aktywuj Cloud Shell
(udostępnienie środowiska i połączenie się z nim powinno zająć tylko kilka chwil).
Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu PROJECT_ID.
gcloud auth list
Wynik polecenia
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
Wynik polecenia
[core] project = <PROJECT_ID>
Jeśli z jakiegoś powodu projekt nie jest ustawiony, po prostu wydaj to polecenie:
gcloud config set project <PROJECT_ID>
Szukasz urządzenia PROJECT_ID? Sprawdź, jakiego identyfikatora użyto w krokach konfiguracji, lub wyszukaj go w panelu konsoli Cloud:
Cloud Shell domyślnie ustawia też niektóre zmienne środowiskowe, które mogą być przydatne podczas wykonywania kolejnych poleceń.
echo $GOOGLE_CLOUD_PROJECT
Wynik polecenia
<PROJECT_ID>
- Na koniec ustaw domyślną strefę i konfigurację projektu.
gcloud config set compute/zone us-central1-f
Możesz wybrać różne strefy. Więcej informacji znajdziesz w artykule Regiony i strefy.
Tworzenie zasobnika Cloud Storage
W zasobniku Cloud Storage będziemy przechowywać utworzony kod oraz skrypty startowe. Aby utworzyć nowy zasobnik Cloud Storage, wykonaj w Cloud Shell to polecenie:
gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID
3. Klonowanie repozytorium źródłowego
Podstawą Twojej witryny będzie istniejąca witryna handlu elektronicznego Fancy Store oparta na repozytorium monolith-to-microservices. Skopiujesz kod źródłowy z repozytorium, aby skoncentrować się na aspektach wdrażania w Compute Engine. Później przeprowadzisz niewielką aktualizację kodu, która pokaże, jak proste jest aktualizowanie w Compute Engine.
Możesz automatycznie sklonować repozytorium kodu do projektu, a także otworzyć Cloud Shell i wbudowany edytor kodu, korzystając z tego linku: Otwórz w Cloud Shell.
Możesz też ręcznie sklonować repozytorium za pomocą tych poleceń w Cloud Shell:
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices
W wierszu poleceń Cloud Shell wykonaj początkową kompilację kodu, aby umożliwić lokalne uruchamianie aplikacji. Działanie skryptu może potrwać kilka minut.
./setup.sh
Przeprowadź testy i sprawdź aplikację. Aby uruchomić serwer WWW, wykonaj to polecenie:
cd microservices npm start
Dane wyjściowe:
Products microservice listening on port 8082! Frontend microservice listening on port 8080! Orders microservice listening on port 8081!
Wyświetl podgląd aplikacji, klikając ikonę podglądu w przeglądarce i wybierając „Podejrzyj na porcie 8080”.
Powinno otworzyć się nowe okno, w którym zobaczysz frontend sklepu internetowego Fancy Store w działaniu.
Po wyświetleniu witryny możesz zamknąć to okno. Aby zatrzymać proces serwera WWW, naciśnij Control+C (Command+C na komputerze Macintosh) w oknie terminala.
4. Tworzenie instancji Compute Engine
Skoro masz już działające środowisko programistyczne, możesz wdrożyć kilka 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 będzie służyć do tego, by instruować instancję, co ma robić, za każdym razem, gdy będzie uruchamiana. W ten sposób instancje zostaną automatycznie skonfigurowane.
Kliknij ikonę ołówka na wstążce Cloud Shell, aby otworzyć edytor kodu.
Przejdź do folderu monolith-to-microservices. Kliknij Plik > Nowy plik i utwórz plik o nazwie startup-script.sh.
W nowym pliku wklej ten kod. Niektóre jego fragmenty zmodyfikujesz po wklejeniu:
#!/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/v8.12.0/node-v8.12.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
Teraz w edytorze kodu znajdź tekst [DEVSHELL_PROJECT_ID] i zastąp go danymi wyjściowymi tego polecenia:
echo $DEVSHELL_PROJECT_ID
Przykładowe dane wyjściowe:
my-gce-codelab-253520
Wiersz kodu w pliku startup-script.sh powinien być teraz podobny do tego:
gs://fancy-store-my-gce-codelab-253520/monolith-to-microservices/microservices/* /fancy-store/
Skrypt startowy wykonuje te zadania:
- instalacja agenta logowania, który automatycznie zbiera logi z syslog,
- Instalacja środowiska Node.js i systemu Supervisor, który uruchamia aplikację jako demon.
- Klonowanie kodu źródłowego aplikacji z zasobnika Cloud Storage i instalowanie zależności
- Konfiguracja systemu Supervisor, który uruchamia aplikację, zapewnia, że aplikacja jest 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.
Teraz skopiuj utworzony plik startup-script.sh do utworzonego wcześniej zasobnika Cloud Storage:
gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-$DEVSHELL_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 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”.
Skopiuj sklonowany kod do zasobnika Cloud Storage:
cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/
Wdrażanie instancji backendowej
Pierwszą wdrożoną instancją będzie instancja backendowa udostępniająca mikroserwisy zamówień i produktów.
Aby utworzyć instancję f1-micro skonfigurowaną do korzystania z utworzonego wcześniej skryptu startowego i oznaczoną tagiem jako instancja backendu, dzięki czemu możesz później zastosować do niej konkretne reguły zapory sieciowej, wykonaj w Cloud Shell to polecenie:
gcloud compute instances create backend \
--machine-type=f1-micro \
--image=debian-9-stretch-v20190905 \
--image-project=debian-cloud \
--tags=backend \
--metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh
Konfigurowanie połączenia z backendem
Przed wdrożeniem frontendu aplikacji musisz zaktualizować konfigurację, wskazując w niej wdrożony backend.
Pobierz zewnętrzny adres IP backendu, który możesz wyświetlić za pomocą tego polecenia w kolumnie EXTERNAL_IP wiersza odpowiadającego instancji backendowej:
gcloud compute instances list
Przykładowe dane wyjściowe:
NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS backend us-central1-a f1-micro 10.128.0.2 34.68.223.88 RUNNING
W edytorze kodu Cloud Shell przejdź do folderu monolith-to-microservices > react-app. W menu edytora kodu wybierz View > Toggle Hidden Files (Widok > Przełącz ukryte pliki), aby wyświetlić plik .env.
Zmodyfikuj plik .env w taki sposób, by wskazywał zewnętrzny adres IP backendu. Ciąg znaków [BACKEND_ADDRESS] poniżej reprezentuje zewnętrzny adres IP instancji backendowej ustalony za pomocą poprzedniego polecenia w narzędziu gcloud.
REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products
Zapisz plik.
Użyj tego polecenia, aby ponownie utworzyć aplikację react-app, co spowoduje zaktualizowanie kodu frontendu:
cd ~/monolith-to-microservices/react-app npm install && npm run-script build
Skopiuj kod aplikacji do zasobnika Cloud Storage:
cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/
Wdrażanie instancji frontendowej
Po skonfigurowaniu kodu możesz wdrożyć instancję frontendową. Aby wdrożyć instancję frontendową, uruchom polecenie podobne do wcześniejszego, ale ta instancja jest oznaczona tagiem „frontend” na potrzeby zapory sieciowej.
gcloud compute instances create frontend \
--machine-type=f1-micro \
--image=debian-9-stretch-v20190905 \
--image-project=debian-cloud \
--tags=frontend \
--metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh
Konfigurowanie sieci
Utwórz 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:
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 teraz działać. Określ zewnętrzny adres IP frontendu. Adres można określić, wyszukując zewnętrzny adres IP instancji frontendu:
gcloud compute instances list
Przykładowe dane wyjściowe:
NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS backend us-central1-a f1-micro 10.128.0.2 104.198.235.171 RUNNING frontend us-central1-a f1-micro 10.128.0.3 34.69.141.9 RUNNING
Uruchomienie i skonfigurowanie instancji może zająć kilka minut. Aby monitorować gotowość aplikacji, wykonaj to polecenie:
watch -n 5 curl http://[EXTERNAL_IP]:8080
Witryna powinna być gotowa, gdy wyświetlą się dane wyjściowe podobne do poniższych. Aby anulować polecenie watch, naciśnij Control+C (Command+C na komputerze Macintosh) w wierszu poleceń.
Otwórz stronę http://[FRONTEND_ADDRESS]:8080 w nowej karcie przeglądarki, aby uzyskać dostęp do witryny. Ciąg znaków [FRONTEND_ADDRESS] reprezentuje zewnętrzny adres IP określony powyżej.
Spróbuj otworzyć strony Produkty i Zamówienia, które też powinny działać.
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. Będziesz korzystać z zarządzanych grup instancji na potrzeby instancji frontendowych oraz backendowych do obsługi funkcji automatycznej naprawy, równoważenia obciążenia, autoskalowania i aktualizacji kroczących.
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 utworzonych przez Ciebie instancji.
Najpierw musisz zatrzymać obie instancje.
gcloud compute instances stop frontend
gcloud compute instances stop backend
Teraz utwórz szablon instancji 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
Sprawdź, czy szablony instancji zostały utworzone:
gcloud compute instance-templates list
Przykładowe dane wyjściowe:
NAME MACHINE_TYPE PREEMPTIBLE CREATION_TIMESTAMP fancy-be f1-micro 2019-09-12T07:52:57.544-07:00 fancy-fe f1-micro 2019-09-12T07:52:48.238-07:00
Tworzenie zarządzanej grupy instancji
Utworzysz 2 zarządzane grupy instancji – jedną dla frontendu i jedną dla backendu. Te zarządzane grupy instancji będą używać wcześniej utworzonych 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.
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
W Twojej aplikacji mikroserwis frontend działa na porcie 8080, a mikroserwisy backend – na porcie 8081 w przypadku zamówień i na porcie 8082 w przypadku produktów. 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, co oznacza, że usługa jest dostępna we wszystkich instancjach w grupie. Te informacje są używane przez system równoważenia obciążenia, który skonfigurujesz później.
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
Skonfiguruj automatyczną naprawę
Aby zwiększyć dostępność samej aplikacji i sprawdzić, czy odpowiada, możesz skonfigurować 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 URUCHOMIONA instancji, co jest działaniem domyślnym.
Utwórz 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
Utwórz regułę zapory sieciowej, która umożliwia 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
Zastosuj 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
Kontynuuj moduł, by dać funkcji automatycznej naprawy dość czasu na rozpoczęcie monitorowania instancji w grupie. Później przeprowadzisz symulację awarii, aby przetestować automatyczną naprawę.
6. Utwórz system 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. Spowoduje to udostępnienie pojedynczego adresu IP systemu równoważenia obciążenia dla wszystkich usług.
Więcej informacji o opcjach równoważenia obciążenia dostępnych w Google Cloud znajdziesz w artykule Omówienie równoważenia obciążenia.
Tworzenie równoważenia obciążenia HTTP(S)
Google Cloud oferuje wiele różnych typów równoważenia obciążenia, ale do obsługi ruchu użyjesz równoważenia obciążenia HTTP(S). Równoważenie obciążenia HTTP(S) ma taką strukturę:
- 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.
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
Utwórz 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
Dodaj usługi backendu.
gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group fancy-fe-mig \ --instance-group-zone us-central1-f \ --global
gcloud compute backend-services add-backend fancy-be-orders \ --instance-group fancy-be-mig \ --instance-group-zone us-central1-f \ --global
gcloud compute backend-services add-backend fancy-be-products \ --instance-group fancy-be-mig \ --instance-group-zone us-central1-f \ --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 utworzoną 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
Aktualizacja konfiguracji
Teraz gdy masz już nowy statyczny adres IP, musisz zaktualizować kod frontendu 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 REGION IP_ADDRESS IP_PROTOCOL TARGET fancy-http-rule 34.102.237.51 TCP fancy-proxy
Zmodyfikuj plik .env w wybranym edytorze tekstu (np. GNU nano) 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.
REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products
Utwórz ponownie aplikację react-app, co spowoduje zaktualizowanie kodu frontendu.
cd ~/monolith-to-microservices/react-app npm install && npm run-script build
Skopiuj kod aplikacji do zasobnika GCS.
cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/
Aktualizowanie instancji frontendowych
Teraz chcesz, aby instancje frontendowe w zarządzanej grupie instancji pobrały nowy kod. Instancje pobierają kod podczas ich uruchamiania, więc możesz uruchomić polecenie kroczącego restartu.
gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
--max-unavailable 100%
Testowanie witryny
Po uruchomieniu polecenia rolling-action restart zaczekaj około 30 sekund na zakończenie przetwarzania instancji. Następnie sprawdzaj stan zarządzanej grupy instancji, dopóki instancje nie wyświetlą się na liście.
watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig
Gdy instancje pojawią się na liście, zakończ polecenie watch, naciskając Control+C (Command+C na komputerze Macintosh).
Sprawdź, czy usługa jest oznaczona jako sprawna.
watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global
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
Gdy instancje pojawią się na liście, zakończ polecenie watch, naciskając Control+C (Command+C na komputerze Macintosh).
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
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 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 w Cloud Shell te polecenia. Utworzą one autoskalowanie w zarządzanych grupach instancji, które automatycznie dodaje instancje, gdy wykorzystanie systemu równoważenia obciążenia wzrasta powyżej 60%, i usuwa je, gdy wykorzystanie systemu równoważenia obciążenia spada poniżej 60%.
gcloud compute instance-groups managed set-autoscaling \ fancy-fe-mig \ --max-num-replicas 5 \ --target-load-balancing-utilization 0.60
gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --max-num-replicas 5 \ --target-load-balancing-utilization 0.60
Włączanie sieci dostarczania treści
Inną funkcją ułatwiającą skalowanie jest włączenie Cloud CDN, czyli usługi sieci dostarczania treści, która zapewnia buforowanie usługi frontendu. Aby to zrobić, możesz wykonać 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, żądanie to dociera do usługi Google Front End, która najpierw szuka odpowiedzi na żądanie użytkownika w pamięci podręcznej usługi Cloud CDN. Jeśli interfejs znajdzie odpowiedź w pamięci podręcznej, wysyła ją do użytkownika. Nazywa się to trafieniem w pamięci podręcznej.
Jeśli frontend 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, interfejs zapisuje odpowiedź w pamięci podręcznej usługi Cloud CDN, by umożliwić jej użycie w kolejnych żądaniach.
8. Aktualizowanie witryny
Aktualizowanie szablonu instancji
Istniejących szablonów instancji nie można edytować. Ponieważ jednak instancje są bezstanowe i cała konfiguracja jest zdefiniowana w skrypcie startowym, aby zmienić ustawienia szablonu, wystarczy zmienić sam obraz podstawowy szablonu instancji. Wprowadzisz teraz prostą zmianę typu maszyny na większą i ją zastosujesz.
Zaktualizuj instancję frontendową, 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.
Zmienisz typ maszyny szablonu instancji z maszyny standardowej f1-micro na maszynę niestandardową o 4 procesorach wirtualnych i pamięci RAM o wielkości 3840 MiB.
Aby zmodyfikować typ maszyny instancji frontend, w Cloud Shell uruchom to polecenie:
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=us-central1-a
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
Monitoruj stan aktualizacji:
watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig
Gdy będziesz mieć więcej niż 1 instancję w stanie URUCHOMIONO,z ustawionym działaniem Brak i szablonem instancji o nazwie fancy-fe-new, skopiuj nazwę jednej z wymienionych maszyn, aby użyć jej w następnym poleceniu.
Control+S (Command+S na komputerze Macintosh), aby zakończyć proces obserwowania.
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/us-central1-f/machineTypes/custom-4-3840
Wprowadzanie zmian w witrynie
Dział marketingu poprosił o zmianę strony głównej witryny. Ich zdaniem powinna zawierać więcej informacji o firmie i produktach, 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 Twoich programistów przygotował już odpowiednie zmiany i umieścił je w pliku o nazwie index.js.new. Możesz skopiować plik do index.js, a zmiany zostaną automatycznie zastosowane. Wykonaj podane niżej instrukcje, by wprowadzić odpowiednie zmiany.
Uruchom te polecenia, aby skopiować zaktualizowany plik z poprawną nazwą, a następnie wyświetlić jego zawartość w celu sprawdzenia dokonanych zmian:
cd ~/monolith-to-microservices/react-app/src/pages/Home mv index.js.new index.js 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 { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
root: {
flexGrow: 1
},
paper: {
width: "800px",
margin: "0 auto",
padding: theme.spacing(3, 2)
}
}));
export default function Home() {
const classes = useStyles();
return (
<div className={classes.root}>
<Paper className={classes.paper}>
<Typography variant="h5">
Fancy Fashion & Style Online
</Typography>
<br />
<Typography variant="body1">
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!
</Typography>
</Paper>
</div>
);
}
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
Następnie ponownie umieść kod w zasobniku Cloud Storage.
cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/
Wypychanie zmian za pomocą aktualizacji kroczących
Możesz teraz wymusić ponowne uruchomienie wszystkich instancji, aby pobrać aktualizację.
gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
--max-unavailable=100%
Po uruchomieniu polecenia rolling-action restart 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 5 gcloud compute instance-groups list-instances fancy-fe-mig
Gdy instancje pojawią się na liście, zakończ polecenie watch, naciskając Control+S (Command+S na komputerze Macintosh).
Uruchom to polecenie, aby potwierdzić, że usługa jest sprawna (wyświetlony zostanie ciąg znaków healthy):
watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global
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
Gdy instancje pojawią się na liście, zakończ polecenie watch, naciskając Control+S (Command+S na komputerze Macintosh).
Aby unieważnić treści w pamięci podręcznej w sieci dostarczania treści i mieć pewność, że wyświetlane są najnowsze treści, wykonaj to działanie:
gcloud compute url-maps invalidate-cdn-cache fancy-map \
--path "/*"
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
Następnie uruchom bezpieczną powłokę w jednej z instancji, w której [INSTANCE_NAME] jest nazwą jednej z instancji z listy:
gcloud compute ssh [INSTANCE_NAME]
W instancji zatrzymaj aplikację za pomocą polecenia supervisorctl.
sudo supervisorctl stop nodeapp; sudo killall node
Opuść instancję.
exit
Monitoruj operacje naprawy.
watch -n 5 gcloud compute operations list \ --filter='operationType~compute.instances.repair.*'
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 us-central1-a/instances/fancy-fe-1vqq 200 DONE 2019-09-12T11:47:14.627-07:00
Gdy zauważysz, że naprawa została wykonana, naciśnij Control+C (Command+S na komputerze Macintosh), aby zamknąć polecenie zegarka. W tym momencie zarządzana grupa instancji odtworzy instancję, aby ją naprawić.
9. Czyszczenie danych
Gdy skończysz, najprostszym sposobem na wyczyszczenie wszystkich wykonanych działań jest usunięcie projektu. Usunięcie projektu spowoduje usunięcie systemu równoważenia obciążenia, instancji, szablonów i innych elementów utworzonych podczas ćwiczenia, aby uniknąć nieoczekiwanych opłat cyklicznych. W Cloud Shell wykonaj to polecenie, gdzie PROJECT_ID to pełny identyfikator projektu, a nie tylko jego nazwa.
gcloud projects delete [PROJECT_ID]
Gdy pojawi się odpowiedni komunikat, potwierdź usunięcie, wpisując „Y”.
10. 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, równoważenia obciążenia oraz kontroli stanu.