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

Pierwsze kroki z Cloud Functions (2 generacji)

1. Wprowadzenie

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

W przeciwnym razie to szkolenie w programie przeprowadzi Cię przez proces tworzenia funkcji w 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 zestaw zaawansowanych funkcji i korzysta z usług Cloud Run oraz Eventarc, co daje Ci większą kontrolę nad wydajnością i skalowalnością oraz zapewnia większą kontrolę nad środowiskiem wykonawczym funkcji i aktywatorami z ponad 90 źródeł zdarzeń.

W tym laboratorium programistycznym pokażemy Ci, jak tworzyć funkcje 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.

Rozszerzona 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 opartych na zdarzeniach wartość ta wynosi obecnie do 10 minut.
Większe instancje: korzystaj z do 16 GB pamięci RAM i 4 vCPU w Cloud Functions, aby wykonywać większe, równoległe zadania wymagające dużej ilości pamięci i zasobów obliczeniowych.
Równoczesność: przetwarzanie do 1000 równoczesnych żądań za pomocą jednej instancji funkcji, co minimalizuje uruchomienia „na zimno” i skraca 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 Eventarc: Cloud Functions zapewnia teraz natywną obsługę Eventarc, co daje dostęp do ponad 90 źródeł zdarzeń korzystających z logów kontrolnych Cloud (BigQuery, Cloud SQL, Cloud Storage itp.). Oczywiście Cloud Functions nadal obsługuje zdarzenia ze źródeł niestandardowych przez bezpośrednie publikowanie 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 odpowiada na zdarzenia w 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 wykorzystaj już istniejący. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.

Nazwa projektu jest wyświetlaną nazwą uczestników tego projektu. Jest to ciąg znaków, którego nie używają interfejsy API Google. W każdej chwili możesz ją zmienić.
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 konta i sprawdzić, czy jest ono dostępne. Po tym kroku nie można go zmienić. Pozostanie ona niezmieniona przez cały czas trwania projektu.
Dostępna jest trzecia wartość, numer projektu, z którego korzystają 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 programu bezpłatnego okresu próbnego o wartości 300 USD.

Uruchom Cloud Shell

Google Cloud można obsługiwać zdalnie z laptopa, ale w tym ćwiczeniu będziesz używać 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

Sprawdź, czy identyfikator projektu jest w Cloud Shell ustawiony i zapisany w zmiennej PROJECT_ID, a element 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 przypadku pierwszej funkcji utwórz uwierzytelnioną funkcję Node.js, która odpowiada na żądania HTTP. Wykorzystajmy też 10-minutowy limit czasu, aby pokazać, jak funkcja może mieć więcej czasu na odpowiadanie na żądania HTTP.

Utwórz

Utwórz folder dla aplikacji i przejdź do niego:

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

Test

Przetestuj funkcję za pomocą tego polecenia:

gcloud functions call nodejs-http-function \
  --gen2 --region $REGION

Powinna wyświetlić się odpowiedź 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 dla aplikacji i przejdź do niego:

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

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

W przypadku następnej funkcji utworzymy funkcję Node.js, która reaguje na zdarzenia z zasobnika 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 dla aplikacji i przejdź do niego:

mkdir ~/hello-storage && cd $_

Utwórz plik index.js, który po prostu odpowiada 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 wysyłany 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 Google typu Administracja – odczyt, Dane – odczyt i Dane – zapis w 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 samodzielnie zapoznać się z bardziej szczegółowymi informacjami dotyczącymi index.js.

Wdróż

Możesz wdrożyć funkcję tak jak wcześniej, używając rozwiązania gcloud. 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ć do niej 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 zdarzenia, 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).

Przejdź do sekcji Compute Engine > Instancje maszyn wirtualnych w Cloud Console 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 przykładu:

...
labelFingerprint: ULU6pAy2C7s=
labels:
  creator: atameldev
...

7. Podział 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 podzielić ruch między wersję pomarańczową i żółtą, musisz znaleźć identyfikatory wersji bazowych 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 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 w ograniczaniu liczby 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 pozbyć się uruchomienia „na zimno” przy pierwszym żądaniu, wdróż ponownie funkcję z flagą --min-instances ustawioną na 1 w ten 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 Cloud Functions (2 generacji) instancja funkcji domyślnie obsługuje 1 żądanie równoległe, ale możesz określić liczbę żądań równoczesnych, 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 powolnym inicjowaniem z poprzedniego kroku. Wyślij do niej 10 żądań i ponownie zobaczysz problem z uruchomieniem „na zimno”, ponieważ konieczne jest utworzenie nowych instancji funkcji do obsługi tych żądań.

Aby rozwiązać problem z zimnym uruchomieniem, wdróż kolejną funkcję z wartością równoczelnoś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.

Testowanie bez równoczesności

Uzyskaj adres URL funkcji:

SLOW_URL=$(gcloud functions describe slow-function --region $REGION --gen2 --format="value(serviceConfig.uri)")

Użyj narzędzia do analizy porównawczej open source o nazwie hey, aby wysłać 10 równoczesnych żądań do powolnej funkcji. Aplikacja hey jest już zainstalowana w Cloud Shell:

hey -n 10 -c 10 $SLOW_URL

W danych wyjściowych hey powinny pojawić się informacje, że niektóre żądania zajmują dużo czasu:

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ść bazowej usługi Cloud Run dla funkcji na 100 (może to być 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 z użyciem równoczesnoś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]     |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

Instancja z jedną funkcją była w stanie obsłużyć wszystkie żądania, a problem z uruchomieniem „na zimno” został rozwiązany dzięki zwiększonej równoczesności.

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 odpowiada na zdarzenia w 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ć równoczesność.