Ta strona została przetłumaczona przez Cloud Translation API.

Hostowanie i skalowanie aplikacji internetowej w Google Cloud przy użyciu Compute Engine

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 ścisłą kontrolę nad infrastrukturą, w której działa witryna, ale w porównaniu z takimi rozwiązaniami jak Google Kubernetes Engine czy App Engine wymaga też nieco większego zarządzania operacyjnego. Compute Engine daje Ci pełną kontrolę nad aspektami infrastruktury, w tym maszynami wirtualnymi, systemem równoważenia obciążenia i nie tylko. Dzisiaj wdrożysz przykładową aplikację e-commerce Fancy Store, aby pokazać, jak można łatwo wdrożyć i skalować witrynę 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 utworzyć 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 ćwiczeń z programowania będziesz mieć instancje w zarządzanych grupach instancji, które zapewniają automatyczną naprawę, równoważenie obciążenia, autoskalowanie i aktualizacje kroczące witryny.

Wymagania wstępne

Aby uzyskać wstępne omówienia zagadnień omawianych w tym module, zapoznaj się z materiałami poniżej:
Witamy w Google Cloud Platform – podstawy GCP
Pierwsze kroki z Google Cloud Compute Engine
Pierwsze kroki z Google Cloud Storage
Pierwsze kroki: Cloud Shell

2. Konfiguracja środowiska

Samodzielne konfigurowanie środowiska

Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub wykorzystaj już istniejący. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.

Zapamiętaj identyfikator projektu, unikalną nazwę we wszystkich projektach Google Cloud (powyższa nazwa jest już zajęta i nie będzie Ci odpowiadać). W dalszej części tego ćwiczenia w Codelabs będzie ona określana jako PROJECT_ID.

Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Google Cloud.

Ukończenie tego ćwiczenia z programowania nie powinno kosztować zbyt wiele. Postępuj zgodnie z instrukcjami podanymi w sekcji „Czyszczenie” W tym samouczku znajdziesz wskazówki, jak wyłączyć zasoby, aby uniknąć naliczania opłat. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.

Włączanie interfejsu Compute Engine API

Następnie musisz włączyć Compute Engine API. Włączenie interfejsu API wymaga zaakceptowania warunków korzystania z usługi oraz odpowiedzialności związanych z płatnościami za ten interfejs.

Wykonaj w Cloud Shell to polecenie, aby włączyć interfejs Compute Engine API:

gcloud services enable compute.googleapis.com

Cloud Shell

Google Cloud można sterować zdalnie z laptopa, ale w ramach tego ćwiczenia z programowania wykorzystasz Cloud Shell – środowisko wiersza poleceń działające w Cloud.

Ta maszyna wirtualna oparta na Debianie zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Oznacza to, że do tego ćwiczenia z programowania wystarczy przeglądarka (tak, działa ona na Chromebooku).

Aby aktywować Cloud Shell z poziomu konsoli Cloud, kliknij Aktywuj Cloud Shell (udostępnienie środowiska i połączenie z nim powinno zająć tylko chwilę).

Zrzut ekranu 2017-06-14 o 10.13.43 PM.png

Po nawiązaniu połączenia z Cloud Shell powinno pojawić się potwierdzenie, że użytkownik jest już uwierzytelniony, a projekt jest już ustawiony na PROJECT_ID.

gcloud auth list

Dane wyjściowe polecenia

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

gcloud config list project

Dane wyjściowe polecenia

[core]
project = <PROJECT_ID>

Jeśli z jakiegoś powodu projekt nie jest skonfigurowany, uruchom po prostu to polecenie:

gcloud config set project <PROJECT_ID>

Szukasz urządzenia PROJECT_ID? Sprawdź identyfikator użyty w krokach konfiguracji lub wyszukaj go w panelu Cloud Console:

Cloud Shell ustawia też domyślnie niektóre zmienne środowiskowe, które mogą być przydatne podczas uruchamiania kolejnych poleceń.

echo $GOOGLE_CLOUD_PROJECT

Dane wyjściowe 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

Wykorzystamy zasobnik Cloud Storage do przechowywania utworzonego kodu oraz skryptów startowych. Wykonaj w Cloud Shell to polecenie, aby utworzyć nowy zasobnik Cloud Storage:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID

3. Klonowanie repozytorium źródłowego

Jako podstawy swojej witryny użyjesz dotychczasowej witryny e-commerce Fancy Store opartej na repozytorium monolitów do mikroserwisów. Sklonujesz kod źródłowy z repozytorium, dzięki czemu skupisz się na aspektach wdrażania w Compute Engine. Później przeprowadzisz niewielką aktualizację kodu, która pokaże, jak proste są aktualizacje 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 skopiować 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 uruchom początkową kompilację kodu, aby umożliwić lokalne uruchamianie aplikacji. Działanie skryptu może potrwać kilka minut.

./setup.sh

Zachowaj należytą staranność i przetestuj swoją aplikację. Uruchom to polecenie, aby uruchomić serwer WWW:

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!

Aby wyświetlić podgląd aplikacji, kliknij ikonę podglądu w przeglądarce i wybierz „Podejrzyj na porcie 8080”.

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

Możesz zamknąć to okno po przejrzeniu witryny. Aby zatrzymać proces serwera WWW, naciśnij Control+C (Command+C na Macu) w oknie terminala.

4. Tworzenie instancji Compute Engine

Po utworzeniu działającego środowiska programistycznego możesz wdrożyć instancje Compute Engine. Wykonasz te czynności:

Utworzysz skrypt startowy służący do konfigurowania instancji.
skopiować kod źródłowy i przesłać 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ę.

Utwórz skrypt startowy

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 z nich będą edytowane 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 instalacja zależności
Konfiguracja funkcji Supervisor, która uruchamia aplikację, upewnij się, że aplikacja jest ponownie uruchomiona, gdy zostanie nieoczekiwanie zamknięta albo zostanie zatrzymana przez administratora lub podmiot przetwarzający, oraz wysyła parametry stdout i stderr aplikacji do syslog, aby agent Logging mógł pobrać dane.

Teraz skopiuj utworzony plik start-script.sh do wcześniej utworzonego zasobnika Cloud Storage:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-$DEVSHELL_PROJECT_ID

Jest 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, więc nie będzie dostępny za pomocą przeglądarki. Instancje Compute Engine będą automatycznie mieć do nich dostęp za pomocą swoich kont usługi.

Kopiowanie kodu do zasobnika Cloud Storage

Gdy instancje uruchamiają się, pobierają kod z zasobnika Cloud Storage, dzięki czemu możesz przechowywać w pliku „.env” zmienne konfiguracyjne pliku z kodem.

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

Wykonaj poniższe polecenie w Cloud Shell, aby utworzyć instancję f1-micro skonfigurowaną do używania wcześniej utworzonego skryptu startowego i oznaczonej jako instancja backendowa. Dzięki temu możesz później zastosować do niej konkretne reguły zapory sieciowej:

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żna wyświetlić za pomocą tego polecenia na karcie EXTERNAL_IP 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 Widok > Przełącz Ukryte pliki, by zobaczyć plik .env.

Zmodyfikuj plik .env, aby wskazywał zewnętrzny adres IP backendu. [BACKEND_ADDRESS] poniżej reprezentuje zewnętrzny adres IP instancji backendowej określony 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ę remarketingu, 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ą za pomocą polecenia podobnego do wcześniejszego, wykonaj poniższe czynności, ale ta instancja jest oznaczona tagiem „frontend” dla 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 dotyczących zapory sieciowej 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

Strona powinna już działać. Określ zewnętrzny adres IP frontendu. Adres można określić, wyszukując wartość EXTERNAL_IP instancji frontendowej:

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 zegarka, naciśnij Control+C (Command+C na komputerach Macintosh) w wierszu polecenia.

Przejdź na stronę http://[FRONTEND_ADDRESS]:8080 w nowej karcie przeglądarki, aby uzyskać dostęp do witryny. [FRONTEND_ADDRESS] to adres EXTERNAL_IP określony powyżej.

Spróbuj otworzyć strony Produkty i Zamówienia – 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 jednej strefie. Zarządzane grupy instancji zapewniają wysoką dostępność aplikacji przez aktywne utrzymywanie instancji w stanie uruchomienia. Wykorzystasz zarządzane grupy 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 umożliwiają określenie typu maszyny, obrazu dysku rozruchowego lub obrazu kontenera, sieci i innych właściwości instancji na potrzeby tworzenia nowych instancji maszyn wirtualnych. Za pomocą szablonów instancji możesz tworzyć instancje w zarządzanej grupie instancji, a nawet poszczególne 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ą korzystać z utworzonych wcześniej szablonów instancji. Będą one skonfigurowane dla 2 instancji – każda będzie uruchamiana we własnej grupie. Nazwy instancji będą tworzone automatycznie na podstawie „nazwa-instancji-podstawowej” z dodanymi 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 frontendu działa na porcie 8080, a mikroserwisy backendu działają na porcie 8081 dla zamówień i na porcie 8082 (produkty). Ponieważ są to porty niestandardowe, należy określić nazwane porty, które pozwolą je zidentyfikować. Nazwane porty to metadane w postaci par klucz-wartość reprezentujących nazwę usługi i port, w 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

Konfigurowanie automatycznej naprawy

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 polega na sprawdzeniu, czy aplikacja odpowiada zgodnie z oczekiwaniami, na podstawie kontroli stanu aplikacji. Sprawdzenie, czy aplikacja odpowiada, jest bardziej szczegółowe niż zwykła weryfikacja stanu URUCHOMIONO, co jest zachowaniem domyślnym.

Utwórz dla frontendu i backendu kontrolę stanu powodującą naprawienie instancji, która 3 razy z rzędu okaże się zła:

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 ćwiczenia w Codelabs, aby dać funkcji automatycznej naprawy dość czasu na monitorowanie 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 równoważeniem obciążenia HTTP(S) z obsługą ruchu 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. Ujawni to pojedynczy adres IP o zrównoważonym obciążeniu 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 będziesz używać równoważenia obciążenia HTTP(S). Struktura równoważenia obciążenia HTTP(S) 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 przyłą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 używasz 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

Utwórz dopasowanie ścieżek, aby umożliwić 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 wiąże 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

Po utworzeniu nowego statycznego adresu IP musisz zaktualizować kod frontendu w taki sposób, by wskazywał nowy adres zamiast używanego wcześniej adresu efemerycznego, który wskazywał instancję backend.

W Cloud Shell przejdź do folderu aplikacji z reakcjami, w którym znajduje się plik .env z 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

Edytuj plik .env w wybranym edytorze tekstu (np. GNU nano), aby wskazywał publiczny adres IP systemu równoważenia obciążenia. [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

Ponownie utwórz aplikację reakcji. Zaktualizuje to kod 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 pobierał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 poczekaj około 30 sekund, aby dać instancji czas na przetworzenie. Następnie sprawdzaj stan zarządzanej grupy instancji, dopóki instancje nie pojawią się na liście.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Gdy elementy pojawią się na liście, zakończ polecenie watch, naciskając Control+C (Command+C na Macu).

Sprawdź, czy usługa jest uznawana za sprawną.

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 elementy pojawią się na liście, zakończ polecenie watch, naciskając Control+C (Command+C na komputerach 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, każdą z 2 instancjami. Konfiguracja jest w pełni funkcjonalna, jednak bez względu na obciążenie jest konfiguracją statyczną. Teraz utworzysz zasadę autoskalowania na podstawie wykorzystania, aby automatycznie skalować każdą zarządzaną grupę instancji.

Automatyczne zmienianie rozmiaru w zależności od wykorzystania

Aby utworzyć zasadę autoskalowania, wykonaj te polecenia w Cloud Shell. Utworzy w zarządzanych grupach instancji autoskalowanie, które automatycznie doda instancje, gdy wykorzystanie systemu równoważenia obciążenia przekracza 60%, i usuwa instancje, 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łącz sieć dostarczania treści

Inną funkcją ułatwiającą skalowanie jest włączenie Cloud CDN – usługi sieciowej do dostarczania treści – w celu zapewnienia buforowania w usłudze frontendu. Aby to zrobić, uruchom w usłudze frontendu to polecenie:

gcloud compute backend-services update fancy-fe-frontend \
    --enable-cdn --global

Teraz gdy użytkownik wysyła żądanie treści z systemu równoważenia obciążenia, żądanie to dociera do frontendu Google, który najpierw szuka odpowiedzi na żądanie użytkownika w pamięci podręcznej usługi Cloud CDN. Jeśli frontend znajdzie odpowiedź w pamięci podręcznej, wysyła ją do użytkownika. Nazywamy to trafieniem w pamięci podręcznej.

W przeciwnym razie, 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, frontend zapisuje odpowiedź w pamięci podręcznej usługi Cloud CDN, by umożliwić jej użycie w kolejnych żądaniach.

8. Zaktualizuj witrynę

Aktualizowanie szablonu instancji

Istniejących szablonów instancji nie można edytować. Ponieważ jednak instancje są bezstanowe, a cała konfiguracja jest wykonywana w skrypcie startowym, wystarczy zmienić szablon instancji tylko wtedy, gdy chcesz zmienić sam główny obraz ustawień szablonu. 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, czy plik istnieje w instancjach zarządzanej grupy instancji.

Zmodyfikujesz typ maszyny w szablonie instancji, przełączając standardowy typ maszyny f1-micro na typ niestandardowy z 4 procesorami wirtualnymi i pamięcią RAM o pojemności 3840 MiB.

Aby zmodyfikować typ maszyny instancji frontend, uruchom w Cloud Shell 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 więcej niż 1 instancja będzie w stanie URUCHOMIONO,wartość ACTION jest ustawiona na Brak, a nazwa nowego szablonu to INSTANCE_TEMPLATE (fancy-fe-new), a następnie skopiuj nazwę jednej z maszyn wymienionych na liście do użycia w następnym poleceniu.

Control+S (Command+S na komputerach Macintosh), aby zakończyć proces oglądania.

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

Twój zespół marketingowy poprosił Cię 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 zadowolić dział 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ć ten plik do index.js i zmiany zostaną automatycznie zastosowane. Wykonaj podane niżej instrukcje, by wprowadzić odpowiednie zmiany.

Uruchom następujące polecenia, skopiuj zaktualizowany plik z poprawną nazwą, a następnie wydrukuj jego zawartość, aby sprawdzić zmiany:

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 &amp; 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 wypchnij 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/

Wypychanie zmian z aktualizacjami kroczącymi

Teraz możesz 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 kroczącego restartu poczekaj około 30 sekund, by dać czas na przetworzenie instancji, a potem sprawdzaj stan zarządzanej grupy instancji, aż instancje pojawią się na liście.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Gdy elementy pojawią się na liście, zakończ polecenie watch, naciskając Control+S (Command+S na Macu).

Uruchom to polecenie, aby sprawdzić, czy usługa jest sprawna (wyświetlony w kontekście stanu sprawnego):

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 elementy pojawią się na liście, zakończ polecenie watch, naciskając Control+S (Command+S na Macu).

Aby unieważnić zawartość pamięci podręcznej w sieci dostarczania treści i upewnić się, że zawsze są wyświetlane nowe treści, uruchom następujące polecenie:

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 sprawdzić, czy kontrola stanu działa, zaloguj się w instancji i zatrzymaj usługi. Wykonaj to polecenie, by znaleźć nazwę instancji:

gcloud compute instance-groups list-instances fancy-fe-mig

Potem utwórz bezpieczną powłokę w jednej z instancji, gdzie INSTANCE_NAME jest jedną z instancji z listy:

gcloud compute ssh [INSTANCE_NAME]

W instancji zatrzymaj aplikację za pomocą polecenia supervisorctl.

sudo supervisorctl stop nodeapp; sudo killall node

Wyjdź z instancji.

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

Po wykryciu naprawy naciśnij Control+C (Command+S na komputerach Macintosh), aby zamknąć polecenie Watch. W tym momencie zarządzana grupa instancji odtwarza instancję, aby ją naprawić.

9. Czyszczenie danych

Najprostszym sposobem na usunięcie 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, które zostały utworzone podczas ćwiczeń z programowania, aby uniknąć nieoczekiwanych opłat cyklicznych. Wykonaj w Cloud Shell podane niżej polecenie, gdzie PROJECT_ID to pełny identyfikator projektu, a nie tylko jego nazwa.

gcloud projects delete [PROJECT_ID]

Potwierdź usunięcie, wpisując „Y” gdy pojawi się odpowiedni komunikat.

10. Gratulacje!

Udało Ci się wdrożyć, przeskalować i zaktualizować witrynę w Compute Engine. Wiesz już, co to jest Compute Engine, z zarządzanymi grupami instancji, równoważeniem obciążenia i kontrolami stanu.