Wprowadzenie do Cloud Functions (2 generacji)

1. Wprowadzenie

Aby rozpocząć pisanie funkcji Cloud Run, możesz skorzystać z tych laboratoriów kodu:

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

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

b35bf95b8bf3d5d8.png

a99b7ace416376c4.png

bd84a6d3004737c5.png

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

55efc1aaa7a4d3ad.png

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:

7ffe5cbb04455448.png

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:

7541800e1e3f299f.png

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:

107029714c32baff.png

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:

8d394a481644c4b6.png

Drugi jest emitowany po utworzeniu maszyny wirtualnej i wygląda tak:

ee0e221d82887cd1.png

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.

  1. Włączanie dzienników kontroli w chmurze typów Administracja – odczyt, Odczyt danych i Zapis danych interfejsu Compute Engine API:

76b7417ea4071241.png

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

8ba79a12ee152d8.png

Kliknij przycisk Add Eventarc Trigger:

655346320a5e3631.png

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:

7d24325ff06c9b05.png

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:

f2e338eed2ccf5a2.png

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.

36ca0c5f39cc89cf.png

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:

391286a08ad3cdde.png

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:

36ca0c5f39cc89cf.png 391286a08ad3cdde.png

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”:

9f5c6877836d62fb.png

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