1. Wprowadzenie
Aby rozpocząć pisanie funkcji Cloud Run, możesz skorzystać z tych laboratoriów kodu:
- Pierwsze kroki z funkcjami HTTP Cloud Run
- Pierwsze kroki z funkcjami Cloud Run uruchamianymi na podstawie zdarzeń
W przeciwnym razie możesz zapoznać się z tym ćwiczeniem, aby dowiedzieć się, jak tworzyć funkcje Cloud Functions (2 generacji).
Omówienie
Cloud Functions (2 generacji) to kolejna wersja Google Cloud Functions, czyli oferty Google Cloud typu funkcje jako usługa. Ta nowa wersja zawiera zaawansowany zestaw funkcji i jest teraz obsługiwana przez Cloud Run i Eventarc, co zapewnia większą kontrolę nad wydajnością i skalowalnością, a także większą kontrolę nad środowiskiem wykonawczym funkcji oraz aktywatorami z ponad 90 źródeł zdarzeń.
W tym laboratorium programistycznym poprowadzimy Cię przez proces tworzenia funkcji w Cloud Functions, które odpowiadają na wywołania HTTP i są wywoływane przez wiadomości Pub/Sub oraz dzienniki Cloud Audit Logs.
Nowości
Ta nowa wersja Cloud Functions zapewnia ulepszone środowisko FaaS oparte na technologii Cloud Run, Cloud Build, Artifact Registry i Eventarc.
Ulepszona infrastruktura
- Dłuższe przetwarzanie żądań: możesz uruchamiać funkcje Cloud Functions na dłużej niż domyślne 5 minut, co ułatwia wykonywanie zadań wymagających dłuższego przetwarzania, takich jak przetwarzanie dużych strumieni danych z Cloud Storage lub BigQuery. W przypadku funkcji HTTP wynosi on do 60 minut. W przypadku funkcji uruchamianych przez zdarzenia jest to obecnie maksymalnie 10 minut.
- Większe instancje: korzystaj z do 16 GB pamięci RAM i 4 vCPU w Cloud Functions, co pozwala na większą ilość równoległych zadań korzystających z pamięci i wymagających dużej mocy obliczeniowej.
- Równoczesność: przetwarzaj do 1000 równoczesnych żądań za pomocą jednej instancji funkcji, minimalizując uruchomienia „na zimno” i skracając czas oczekiwania podczas skalowania.
- Minimalna liczba instancji: zapewnij wstępnie podgrzane instancje, aby skrócić czas uruchamiania „na zimno” i upewnić się, że czas uruchamiania aplikacji nie wpływa na jej wydajność.
- Podział ruchu: obsługa wielu wersji funkcji, podział ruchu między różne wersje i przywrócenie poprzedniej wersji funkcji.
Większe pokrycie zdarzeń i obsługa CloudEvents
- Integracja z Eventarc: funkcja Cloud Functions obsługuje teraz natywny interfejs API Eventarc, który umożliwia korzystanie z ponad 90 źródeł zdarzeń za pomocą dzienników Cloud Audit (BigQuery, Cloud SQL, Cloud Storage itp.). Oczywiście Cloud Functions obsługuje też zdarzenia z niestandardowych źródeł, publikując je bezpośrednio w Cloud Pub/Sub.
- Format CloudEvent: wszystkie funkcje oparte na zdarzeniach są zgodne ze standardem branżowym CloudEvents ( cloudevents.io), niezależnie od źródła, aby zapewnić spójne środowisko programistyczne. Ładunki są wysyłane za pomocą ustrukturyzowanego CloudEvent z ładunkiem cloudevent.data i implementują standard CloudEvent.
Czego się nauczysz
- Omówienie Cloud Functions (2 generacji).
- Jak napisać funkcję, która odpowiada na wywołania HTTP.
- Jak napisać funkcję, która odpowiada na wiadomości Pub/Sub.
- Jak napisać funkcję, która reaguje na zdarzenia Cloud Storage.
- Jak napisać funkcję, która reaguje na logi kontrolne Cloud.
- Jak podzielić ruch między 2 wersje.
- Jak pozbyć się uruchomień „na zimno” za pomocą minimalnej liczby instancji
- Jak ustawić współbieżność.
2. Konfiguracja i wymagania
Konfiguracja środowiska w samodzielnym tempie
- 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ć.
- Nazwa projektu to wyświetlana nazwa uczestników tego projektu. Jest to ciąg znaków, którego nie używają interfejsy API Google. Możesz ją zaktualizować w dowolnym momencie.
- Identyfikator projektu musi być niepowtarzalny we wszystkich projektach Google Cloud i jest niezmienny (nie można go zmienić po jego ustawieniu). Cloud Console automatycznie generuje unikalny ciąg znaków. Zwykle nie ma znaczenia, jaki to ciąg. W większości laboratoriów z kodem musisz odwoływać się do identyfikatora projektu (zazwyczaj jest to
PROJECT_ID
). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować inny losowy. Możesz też spróbować użyć własnego adresu i sprawdzić, czy jest on dostępny. Po tym kroku nie można go zmienić. Pozostanie ona niezmieniona przez cały czas trwania projektu. - Informacyjnie: istnieje jeszcze 3 wartość, numer projektu, którego używają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.
- Następnie musisz włączyć rozliczenia w konsoli Cloud, aby korzystać z zasobów i interfejsów API Cloud. Przejście przez ten Codelab nie powinno wiązać się z wielkimi kosztami, jeśli w ogóle będą jakieś. Aby wyłączyć zasoby, aby nie generować opłat po zakończeniu samouczka, możesz usunąć utworzone zasoby lub cały projekt. 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.
Uruchamianie Cloud Shell
Google Cloud można obsługiwać zdalnie z laptopa, ale w tym ćwiczeniu będziesz korzystać z Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.
W konsoli Google Cloud kliknij ikonę Cloud Shell na pasku narzędzi w prawym górnym rogu:
Uzyskanie dostępu do środowiska i połączenie się z nim powinno zająć tylko kilka chwil. Po jego zakończeniu powinno wyświetlić się coś takiego:
Ta maszyna wirtualna 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 poprawia wydajność sieci i uwierzytelnianie. Wszystkie zadania w tym CodeLab możesz wykonać w przeglądarce. Nie musisz niczego instalować.
Konfigurowanie gcloud
W Cloud Shell sprawdź, czy identyfikator projektu jest ustawiony i zapisany w zmiennej PROJECT_ID
, a zmienna REGION
ma wartość us-west1
:
gcloud config set project [YOUR-PROJECT-ID] PROJECT_ID=$(gcloud config get-value project) REGION=us-west1
Włącz interfejsy API
Włącz wszystkie niezbędne usługi:
gcloud services enable \ artifactregistry.googleapis.com \ cloudfunctions.googleapis.com \ cloudbuild.googleapis.com \ eventarc.googleapis.com \ run.googleapis.com \ logging.googleapis.com \ pubsub.googleapis.com
3. Funkcja HTTP
W pierwszej kolejności utwórzmy funkcję Node.js, która odpowiada na żądania HTTP i która jest uwierzytelniana. Użyjemy też 10-minutowego limitu czasu, aby pokazać, że funkcja może mieć więcej czasu na odpowiadanie na żądania HTTP.
Utwórz
Utwórz folder aplikacji i otwórz go:
mkdir ~/hello-http && cd $_
Utwórz plik index.js
, który po prostu odpowiada na żądania HTTP:
const functions = require('@google-cloud/functions-framework'); functions.http('helloWorld', (req, res) => { res.status(200).send('HTTP with Node.js in GCF 2nd gen!'); });
Utwórz plik package.json
, aby określić zależności:
{ "name": "nodejs-functions-gen2-codelab", "version": "0.0.1", "main": "index.js", "dependencies": { "@google-cloud/functions-framework": "^2.0.0" } }
Wdróż
Wdróż funkcję:
gcloud functions deploy nodejs-http-function \ --gen2 \ --runtime nodejs16 \ --entry-point helloWorld \ --source . \ --region $REGION \ --trigger-http \ --timeout 600s
Chociaż nie jest to konieczne na tym etapie, należy pamiętać o limitie czasu wynoszącym 600 sekund. Dzięki temu funkcja może mieć dłuższy limit czasu odpowiedzi na żądania HTTP.
Po wdrożeniu funkcji możesz ją wyświetlić w sekcji Cloud Functions w konsoli Cloud:
Test
Przetestuj funkcję za pomocą tego polecenia:
gcloud functions call nodejs-http-function \ --gen2 --region $REGION
W odpowiedzi powinien wyświetlić się komunikat HTTP with Node.js in GCF 2nd gen!
.
4. Funkcja Pub/Sub
Drugą funkcję, którą utworzymy, będzie funkcja w Pythonie, która będzie wywoływana przez wiadomość Pub/Sub opublikowaną w określonym temacie.
Konfigurowanie tokenów uwierzytelniających Pub/Sub
Jeśli konto usługi Pub/Sub zostało włączone 8 kwietnia 2021 r. lub wcześniej, przypisz do niego rolę iam.serviceAccountTokenCreator
:
PROJECT_NUMBER=$(gcloud projects list --filter="project_id:$PROJECT_ID" --format='value(project_number)') gcloud projects add-iam-policy-binding $PROJECT_ID \ --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \ --role roles/iam.serviceAccountTokenCreator
Utwórz
Utwórz temat Pub/Sub, który będzie używany w przykładzie:
TOPIC=cloud-functions-gen2-topic gcloud pubsub topics create $TOPIC
Utwórz folder aplikacji i otwórz go:
mkdir ~/hello-pubsub && cd $_
Utwórz plik main.py
, który po prostu rejestruje wiadomość zawierającą identyfikator CloudEvent:
import functions_framework @functions_framework.cloud_event def hello_pubsub(cloud_event): print('Pub/Sub with Python in GCF 2nd gen! Id: ' + cloud_event['id'])
Aby określić zależności, utwórz plik requirements.txt
z podaną niżej treścią:
functions-framework==3.*
Wdróż
Wdróż funkcję:
gcloud functions deploy python-pubsub-function \ --gen2 \ --runtime python39 \ --entry-point hello_pubsub \ --source . \ --region $REGION \ --trigger-topic $TOPIC
Po wdrożeniu funkcji możesz ją wyświetlić w sekcji Cloud Functions w konsoli Cloud:
Test
Przetestuj funkcję, wysyłając wiadomość do tematu:
gcloud pubsub topics publish $TOPIC --message="Hello World"
W logach powinien pojawić się otrzymany CloudEvent:
gcloud functions logs read python-pubsub-function \ --region $REGION --gen2 --format "value(log)"
5. Funkcja Cloud Storage
Następną funkcję utwórz w Node.js, aby reagowała na zdarzenia z zasobinku Cloud Storage.
Skonfiguruj
Aby korzystać z funkcji Cloud Storage, przypisz rolę uprawnień pubsub.publisher
do konta usługi Cloud Storage:
SERVICE_ACCOUNT=$(gsutil kms serviceaccount -p $PROJECT_NUMBER) gcloud projects add-iam-policy-binding $PROJECT_ID \ --member serviceAccount:$SERVICE_ACCOUNT \ --role roles/pubsub.publisher
Utwórz
Utwórz folder aplikacji i otwórz go:
mkdir ~/hello-storage && cd $_
Utwórz plik index.js
, który po prostu reaguje na zdarzenia Cloud Storage:
const functions = require('@google-cloud/functions-framework'); functions.cloudEvent('helloStorage', (cloudevent) => { console.log('Cloud Storage event with Node.js in GCF 2nd gen!'); console.log(cloudevent); });
Utwórz plik package.json
, aby określić zależności:
{ "name": "nodejs-functions-gen2-codelab", "version": "0.0.1", "main": "index.js", "dependencies": { "@google-cloud/functions-framework": "^2.0.0" } }
Wdróż
Najpierw utwórz zasobnik Cloud Storage (lub użyj istniejącego zasobnika):
export BUCKET="gs://gcf-gen2-storage-$PROJECT_ID" gsutil mb -l $REGION $BUCKET
Wdróż funkcję:
gcloud functions deploy nodejs-storage-function \ --gen2 \ --runtime nodejs16 \ --entry-point helloStorage \ --source . \ --region $REGION \ --trigger-bucket $BUCKET \ --trigger-location $REGION
Po wdrożeniu funkcji możesz ją wyświetlić w sekcji Cloud Functions w Cloud Console.
Test
Przetestuj funkcję, przesyłając plik do zasobnika:
echo "Hello World" > random.txt gsutil cp random.txt $BUCKET/random.txt
W logach powinien pojawić się otrzymany CloudEvent:
gcloud functions logs read nodejs-storage-function \ --region $REGION --gen2 --limit=100 --format "value(log)"
6. Funkcja logów kontrolnych Cloud
Następną funkcję, którą utworzymy, będzie funkcja Node.js, która po utworzeniu instancji maszyny wirtualnej Compute Engine otrzymuje zdarzenie z dziennika Cloud Audit Log. W odpowiedzi dodaje etykietę do nowo utworzonej maszyny wirtualnej, podając jej twórcę.
Określanie nowo utworzonych maszyn wirtualnych Compute Engine
Podczas tworzenia maszyny wirtualnej Compute Engine generuje 2 logi audytu.
Pierwszy jest emitowany na początku tworzenia maszyny wirtualnej i wygląda tak:
Drugi jest emitowany po utworzeniu maszyny wirtualnej i wygląda tak:
Zwróć uwagę na pole operacji z wartościami first: true
i last: true
. Drugi dziennik kontrolny zawiera wszystkie informacje potrzebne do oznaczenia instancji, dlatego użyjemy flagi last: true
, aby wykryć ją w Cloud Functions.
Skonfiguruj
Aby używać funkcji dziennika kontrolnego Cloud, musisz włączyć dzienniki kontrolne dla Eventarc. Musisz też użyć konta usługi z rolą eventarc.eventReceiver
.
- Włączanie dzienników kontroli w chmurze typów Administracja – odczyt, Odczyt danych i Zapis danych interfejsu Compute Engine API:
- Przypisz domyślnemu kontu usługi Compute Engine rolę uprawnień
eventarc.eventReceiver
:
gcloud projects add-iam-policy-binding $PROJECT_ID \ --member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \ --role roles/eventarc.eventReceiver
Pobierz kod
Skopiuj repozytorium zawierające aplikację:
git clone https://github.com/GoogleCloudPlatform/eventarc-samples.git
Otwórz katalog aplikacji:
cd eventarc-samples/gce-vm-labeler/gcf/nodejs
Plik index.js
zawiera kod aplikacji, który odbiera log kontrolny zapakowany w CloudEvent. Następnie wyodrębnia szczegóły instancji maszyny wirtualnej Compute Engine i ustawia etykietę dla tej instancji. Możesz też samodzielnie zapoznać się ze szczegółami index.js
.
Wdróż
Funkcję możesz wdrożyć za pomocą funkcji gcloud
, tak jak poprzednio. Zwróć uwagę, że funkcja filtruje logi kontroli pod kątem wstawień Compute Engine z flagą --trigger-event-filters
:
gcloud functions deploy gce-vm-labeler \ --gen2 \ --runtime nodejs16 \ --entry-point labelVmCreation \ --source . \ --region $REGION \ --trigger-event-filters="type=google.cloud.audit.log.v1.written,serviceName=compute.googleapis.com,methodName=beta.compute.instances.insert" \ --trigger-location us-central1
Funkcję możesz też wdrożyć i dodać wyzwalacz Eventarc w konsoli Google Cloud.
Najpierw przejdź do sekcji Cloud Functions i utwórz funkcję w środowisku 2 generacji:
Kliknij przycisk Add Eventarc Trigger
:
Otworzy się panel boczny po prawej stronie, w którym możesz wybrać różnych dostawców zdarzeń i zdarzenia do użycia w aktywaterze Eventarc.
Wybierz odpowiedniego dostawcę zdarzeń i zdarzenie, a potem kliknij Save Trigger
:
Na następnej stronie możesz zaktualizować pliki index.js
i package.json
za pomocą plików index.js
i package.json
na GitHub i kliknąć przycisk Deploy
:
Test
Aby przetestować funkcję dziennika kontroli, musisz utworzyć maszynę wirtualną Compute Engine w konsoli Cloud (można też utworzyć maszyny wirtualne za pomocą gcloud
, ale nie generują one dzienników kontroli).
W konsoli Cloud Console otwórz sekcję Compute Engine > Instancje maszyn wirtualnych i utwórz nową maszynę wirtualną. Po zakończeniu tworzenia maszyny wirtualnej w konsoli Google Cloud w sekcji Informacje podstawowe powinna pojawić się etykieta creator
. Możesz też użyć tego polecenia:
gcloud compute instances describe YOUR_VM_NAME
Etykieta powinna się pojawić w wyjściu w postaci podobnej do tego:
... labelFingerprint: ULU6pAy2C7s= labels: creator: atameldev ...
7. Dzielenie ruchu
Cloud Functions (2 generacji) obsługuje wiele wersji funkcji, dzieląc ruch między różne wersje i przywracając funkcję do poprzedniej wersji. Jest to możliwe, ponieważ funkcje 2 generacji to pod spodem usługi Cloud Run.
W tym kroku wdroż 2 wersje funkcji, a następnie podziel ruch między nie w proporcji 50–50.
Utwórz
Utwórz folder aplikacji i otwórz go:
mkdir ~/traffic-splitting && cd $_
Utwórz plik main.py
z funkcją Pythona, która odczytuje zmienną środowiskową koloru i odpowie Hello World
w tym kolorze tła:
import os color = os.environ.get('COLOR') def hello_world(request): return f'<body style="background-color:{color}"><h1>Hello World!</h1></body>'
Wdróż
Wdróż pierwszą wersję funkcji z pomarańczowym tłem:
COLOR=orange gcloud functions deploy hello-world-colored \ --gen2 \ --runtime python39 \ --entry-point hello_world \ --source . \ --region $REGION \ --trigger-http \ --allow-unauthenticated \ --update-env-vars COLOR=$COLOR
Jeśli w tym momencie otworzysz w przeglądarce funkcję, aby wyświetlić w niej aktywator HTTP (dane wyjściowe URI z powyższego polecenia wdrożenia), powinna się ona wyświetlić na pomarańczowym tle: Hello World
.
Wdróż drugą wersję z żółtym tłem:
COLOR=yellow gcloud functions deploy hello-world-colored \ --gen2 \ --runtime python39 \ --entry-point hello_world \ --source . \ --region $REGION \ --trigger-http \ --allow-unauthenticated \ --update-env-vars COLOR=$COLOR
Ponieważ jest to najnowsza wersja, podczas testowania funkcji powinieneś/powinnaś zobaczyć Hello World
z żółtym tłem:
Podział ruchu na 50–50
Aby rozdzielić ruch na wersje pomarańczową i żółtą, musisz znaleźć identyfikatory wersji docelowych usług Cloud Run. Aby wyświetlić identyfikatory wersji, użyj tego polecenia:
gcloud run revisions list --service hello-world-colored \ --region $REGION --format 'value(REVISION)'
Dane wyjściowe powinny być podobne do tych:
hello-world-colored-00001-man hello-world-colored-00002-wok
Teraz podziel ruch między te 2 wersje w ten sposób: (zaktualizuj X-XXX
zgodnie z nazwami swoich wersji):
gcloud run services update-traffic hello-world-colored \ --region $REGION \ --to-revisions hello-world-colored-0000X-XXX=50,hello-world-colored-0000X-XXX=50
Test
Przetestuj funkcję, otwierając jej publiczny adres URL. Połowa wersji powinna być pomarańczowa, a druga połowa żółta:
Więcej informacji znajdziesz w artykule Przywracanie, wdrażanie stopniowe i migracja ruchu.
8. Minimalna liczba instancji
W usłudze Cloud Functions (2 generacji) można określić minimalną liczbę instancji funkcji, które mają być utrzymywane w gotowości do obsługi żądań. Jest to przydatne, ponieważ ogranicza liczbę uruchomień „na zimno”.
W tym kroku wdrożysz funkcję z wolną inicjalizacją. Zaobserwujesz problem z uruchomieniem „na zimno”. Następnie wdróż funkcję z wartością minimalnej liczby instancji ustawioną na 1, aby uniknąć uruchomień „na zimno”.
Utwórz
Utwórz folder aplikacji i otwórz go:
mkdir ~/min-instances && cd $_
Utwórz plik main.go
. Ta usługa w Go ma funkcję init
, która na 10 sekund przechodzi w stan uśpienia, aby symulować długą inicjalizację. Zawiera też funkcję HelloWorld
, która odpowiada na wywołania HTTP:
package p import ( "fmt" "net/http" "time" ) func init() { time.Sleep(10 * time.Second) } func HelloWorld(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "Slow HTTP Go in GCF 2nd gen!") }
Wdróż
Wdróż pierwszą wersję funkcji z domyślną minimalną wartością instancji równą 0:
gcloud functions deploy slow-function \ --gen2 \ --runtime go116 \ --entry-point HelloWorld \ --source . \ --region $REGION \ --trigger-http \ --allow-unauthenticated
Testowanie funkcji za pomocą tego polecenia:
gcloud functions call slow-function \ --gen2 --region $REGION
W przypadku pierwszego wywołania nastąpi 10-sekundowa zwłoka (zimny start), a potem zobaczysz wiadomość. Kolejne wywołania powinny być realizowane natychmiast.
Ustawianie minimalnej liczby instancji
Aby uniknąć uruchamiania „na zimno” przy pierwszym żądaniu, ponownie wdrożyć funkcję z flagą --min-instances
ustawioną na 1 w następujący sposób:
gcloud functions deploy slow-function \ --gen2 \ --runtime go116 \ --entry-point HelloWorld \ --source . \ --region $REGION \ --trigger-http \ --allow-unauthenticated \ --min-instances 1
Test
Ponownie przetestuj funkcję:
gcloud functions call slow-function \ --gen2 --region $REGION
Opóźnienie 10 sekund nie powinno już występować w przypadku pierwszego żądania. Dzięki minimalnej liczbie instancji problem z uruchomieniem „na zimno” podczas pierwszego wywołania (po długim czasie bez wywołania) został rozwiązany.
Więcej informacji znajdziesz w artykule Używanie minimalnej liczby instancji.
9. Równoczesność
W usłudze Cloud Functions (2 generacji) instancja funkcji domyślnie obsługuje 1 jednoczesne żądanie, ale możesz określić liczbę żądań, które mogą być przetwarzane jednocześnie przez instancję. Może to być też przydatne w zapobieganiu zimnym uruchomieniom, ponieważ nie trzeba tworzyć nowej instancji funkcji dla każdej równoległej prośby.
W tym kroku użyjesz funkcji z powolną inicializacją z poprzedniego kroku. Wyślij 10 żądań i ponownie sprawdź problem z uruchomieniem „na zimno”, ponieważ do obsługi żądań trzeba utworzyć nowe instancje funkcji.
Aby rozwiązać problem z zimnym uruchomieniem, wdróż kolejną funkcję z wartością równoczesności 100. Zauważysz, że 10 żądań nie powoduje już problemu z uruchomieniem i że pojedyncza instancja funkcji może obsłużyć wszystkie żądania.
Test bez równoległości
Uzyskaj adres URL funkcji:
SLOW_URL=$(gcloud functions describe slow-function --region $REGION --gen2 --format="value(serviceConfig.uri)")
Użyj narzędzia do porównywania open source o nazwie hey
, aby wysłać 10 jednoczesnych żądań do funkcji o wolnej szybkości. Aplikacja hey
jest już zainstalowana w Cloud Shell:
hey -n 10 -c 10 $SLOW_URL
W wyjściu polecenia hey
powinno być widoczne, że niektóre żądania trwają długo:
Summary: Total: 10.9053 secs Slowest: 10.9048 secs Fastest: 0.4439 secs Average: 9.7930 secs Requests/sec: 0.9170 Total data: 310 bytes Size/request: 31 bytes Response time histogram: 0.444 [1] |■■■■ 1.490 [0] | 2.536 [0] | 3.582 [0] | 4.628 [0] | 5.674 [0] | 6.720 [0] | 7.767 [0] | 8.813 [0] | 9.859 [0] | 10.905 [9] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
Dzieje się tak, ponieważ do obsługi żądań tworzonych jest więcej instancji funkcji. Jeśli sprawdzisz liczbę aktywnych instancji funkcji, zobaczysz też, że w pewnym momencie utworzono więcej niż 1 instancję, która powoduje problem z uruchomieniem „na zimno”:
Wdróż
Wdrażanie nowej funkcji identycznej z poprzednią. Po wdrożeniu zwiększysz jego równoczesność:
gcloud functions deploy slow-concurrent-function \ --gen2 \ --runtime go116 \ --entry-point HelloWorld \ --source . \ --region $REGION \ --trigger-http \ --allow-unauthenticated \ --min-instances 1
Ustawianie równoczesności
Ustaw równoczesność podstawowej usługi Cloud Run dla funkcji na 100 (może wynosić maksymalnie 1000). Dzięki temu co najmniej 100 żądań może być obsługiwanych przez jedną instancję funkcji:
gcloud run services update slow-concurrent-function \ --concurrency 100 \ --cpu 1 \ --region $REGION
Testowanie współbieżności
Uzyskaj adres URL funkcji:
SLOW_CONCURRENT_URL=$(gcloud functions describe slow-concurrent-function --region $REGION --gen2 --format="value(serviceConfig.uri)")
Następnie użyj hey
, aby wysłać 10 jednoczesnych żądań:
hey -n 10 -c 10 $SLOW_CONCURRENT_URL
W danych wyjściowych polecenia hey
powinno się wyświetlić, że wszystkie żądania są przetwarzane szybko:
Summary: Total: 0.2164 secs Slowest: 0.2163 secs Fastest: 0.0921 secs Average: 0.2033 secs Requests/sec: 46.2028 Total data: 310 bytes Size/request: 31 bytes Response time histogram: 0.092 [1] |■■■■ 0.105 [0] | 0.117 [0] | 0.129 [0] | 0.142 [0] | 0.154 [0] | 0.167 [0] | 0.179 [0] | 0.191 [0] | 0.204 [0] | 0.216 [9] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
Pojedyncza instancja funkcji była w stanie obsłużyć wszystkie żądania, a dzięki zwiększonej współbieżności problem uruchomień „na zimno” zniknął.
Więcej informacji znajdziesz w sekcji współbieżność.
10. Gratulacje!
Gratulujemy ukończenia ćwiczenia.
Omówione zagadnienia
- Omówienie Cloud Functions (2 generacji).
- Jak napisać funkcję, która odpowiada na wywołania HTTP.
- Jak napisać funkcję, która odpowiada na wiadomości Pub/Sub.
- Jak napisać funkcję, która reaguje na zdarzenia Cloud Storage.
- Jak napisać funkcję, która reaguje na logi kontrolne Cloud.
- Jak podzielić ruch między 2 wersje.
- Jak pozbyć się uruchomień „na zimno” za pomocą minimalnej liczby instancji
- Jak ustawić współbieżność.