GKE-Kosten am Anfang des Entwicklungszyklus mit GitHub schätzen

Last reviewed 2022-12-15 UTC

Autopilot Standard

In dieser Anleitung wird gezeigt, wie Sie die Kostensichtbarkeit von Google Kubernetes Engine (GKE) nach links zu Ihrem Entwicklungsteam verschieben. Diese Praxis der Linksverschiebung generiert früh während des Prozesses ein Bewusstsein für Kosten und hilft Ihnen, unerwartete Kosten in Ihrer Google Cloud-Rechnung zu vermeiden.

Diese Anleitung richtet sich an Entwickler, Operatoren und FinOps-Experten, die Kosten in GKE-Clustern optimieren möchten und GitHub in der Produktion verwenden. Wenn Sie stattdessen GitLab verwenden, lesen Sie die Informationen unter GKE-Kosten am Anfang des Entwicklungszyklus mit GitLab schätzen.

In dieser Anleitung wird davon ausgegangen, dass Sie mit Docker, GitHub, Kubernetes, GKE, Cloud Build und Linux vertraut sind.

Übersicht

Viele Teams, die die öffentliche Cloud nutzen, sind nicht an den "Pay as you go"-Abrechnungsstil gewöhnt. Häufig verstehen sie nicht vollständig, in welcher Umgebung ihre Anwendungen ausgeführt werden, in diesem Fall GKE. Mit dem FinOps-Betriebsmodell wird diese Kultur der finanziellen Rechenschaftspflicht gefördert. Eine FinOps-Best-Practice besteht darin, Teams Echtzeitinformationen über ihre Ausgaben bereitzustellen, damit Kostenprobleme so schnell wie möglich behoben werden können.

In diesem Dokument erfahren Sie, wie Sie noch einen Schritt weiter gehen und Kosten schätzen, bevor sie zu einer Ausgabe in der Abrechnung werden. Wie auf der GitHub-Website erläutert: "Auf GitHub sind in jede Pull-Anfrage einfache Code-Review-Tools integriert." So können Sie "Projekte weiterentwickeln, neue Features vorschlagen und Implementierungsdetails besprechen, bevor Sie den Quellcode ändern". Die beste Zeit für eine Kostenschätzung ist früh während des Entwicklungsprozesses und des Code Review. Auf diese Weise können Fachkräfte Alternativen zu den Kostenauswirkungen neuer Features und Fehlerkorrekturen verstehen und besprechen, bevor sie zu einem Problem werden. Im folgenden Diagramm wird eine solche Vorgehensweise zusammengefasst.

Best Practice zur frühzeitigen Kostenschätzung.

Wie das Diagramm zeigt, schätzt ein Entwickler die GKE-Kosten in seiner lokalen Umgebung, idealerweise bei der Erstellung. Mit dieser Schätzung erhält er ein Verständnis der monatlichen Kosten für die Produktionsarbeitslast. Wenn das Feature oder die Fehlerkorrektur abgeschlossen ist, schlägt der Dienst eine Pull-Anfrage vor, die Cloud Build zur Prüfung der Differenz zwischen den alten und neuen Kosten veranlasst. Bei Erhöhungen über einen vordefinierten Schwellenwert kann er einen neuen Code Review anfordern. Mit dieser Vorgehensweise können Entwickler sich ihrer Arbeitslastkapazität bewusster werden und Anwendungsprobleme proaktiv beheben, anstatt jedes Mal weitere Ressourcen hinzuzufügen, wenn eine Instabilität in der Produktion festgestellt wird.

Ziele

Erstellen Sie das Kubernetes-Image für die Kostenschätzung und übertragen Sie es per Push.
Erstellen Sie ein GitHub-Repository.
Verbinden Sie Cloud Build mit dem GitHub-Repository.
Übertragen Sie den Beispielcode per Push in Ihr GitHub-Repository.
Ändern Sie den Code und schlagen Sie eine Pull-Anfrage vor, um die Kostenschätzung in Aktion zu sehen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

Rufen Sie in der Google Cloud Console die Seite für die Projektauswahl auf.

Zur Projektauswahl
Wählen Sie ein Google Cloud-Projekt aus oder erstellen Sie eines.

Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Aktivieren Sie Cloud Shell in der Google Cloud Console.

Cloud Shell aktivieren

Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

Umgebung vorbereiten

Klonen Sie in Cloud Shell das GitHub-Repository gke-shift-left-cost.
```
git clone https://github.com/GoogleCloudPlatform/gke-shift-left-cost
cd gke-shift-left-cost
```
Der Code in diesem Repository ist in folgende Ordner strukturiert:
- Root: Enthält eine Dockerfile-Datei, die zum Erstellen des Kostenschätzungs-Images verwendet wird, und die Datei main.go, die die Befehlszeilenlogik für das Schätzungstool implementiert.
- api/: Enthält die Golang API zum Bearbeiten von Kubernetes-Objekten und zum Durchführen der Kostenschätzung.
- samples/: Enthält Beispiele von Kubernetes-Manifesten, damit Sie mit dem Prozess experimentieren können, bevor Sie ihn in Ihrer Organisation implementieren.
Legen Sie Ihre Google Cloud-Projekt-ID, Ihren GitHub-Nutzer und Ihre E-Mail-Adresse sowie einen weiteren GitHub-Nutzer fest, der als FinOps-Prüfer fungieren soll:
```
export GCP_PROJECT_ID=YOUR_PROJECT_ID
export GITHUB_USER=YOUR_GITHUB_USER
export GITHUB_EMAIL=YOUR_GITHUB_EMAIL_ADDRESS
export GITHUB_FINOPS_REVIEWER_USER=ANOTHER_GITHUB_USER
```
Dabei gilt:
- YOUR_PROJECT_ID: die Google Cloud-Projekt-ID des Projekts, das Sie in dieser Anleitung verwenden.
- YOUR_GITHUB_USER: der Nutzer, mit dem Sie sich in Ihrem GitHub-Konto anmelden.
- YOUR_GITHUB_EMAIL_ADDRESS: die E-Mail-Adresse, die Sie in Ihrem GitHub-Konto verwenden.
- ANOTHER_GITHUB_USER: ein anderer GitHub-Nutzer, der als FinOps-Prüfer fungieren soll. Beachten Sie, dass Sie für diese Anleitung diesen Nutzer als Repository-Mitbearbeiter hinzufügen müssen und es daher nicht selbst sein können. Achten Sie darauf, dass der Nutzer Ihre Einladung nach dem Erstellen der Einladung annimmt, damit die Anleitung nicht unterbrochen wird.

Legen Sie das Google Cloud-Projekt fest und aktivieren Sie die erforderlichen APIs:

gcloud config set project $GCP_PROJECT_ID

gcloud services enable cloudbilling.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com

Erstellen Sie das Kubernetes-Image für die Kostenschätzung und übertragen Sie es per Push.

Das in dieser Anleitung enthaltene Tool zur Kostenschätzung von Kubernetes ist nur ein Beispiel dafür, was möglich ist. Er bietet die Möglichkeit, die Kosten für Kubernetes-Objekte vom Typ DaemonSet, Deployment, StatefulSet, ReplicaSet, HorizontalPodAutoScaler und PersistentVolumeClaim zu schätzen. Sie können auch ein eigenes Tool zur Kostenschätzung implementieren oder Pull-Anfragen mit den gewünschten Verbesserungen vorschlagen.

Erlauben Sie in Cloud Shell application-default die Verwendung Ihrer Anmeldedaten:
```
gcloud auth application-default login
```
Erstellen Sie das Kubernetes-Binärprogramm für die Kostenschätzung:
```
mkdir ./bin
go test ./api
go build -v -o ./bin/k8s-cost-estimator .
```

Testen Sie das Binärprogramm, indem Sie in einem Beispielordner die Kostenschätzung ausführen:

./bin/k8s-cost-estimator \
    --k8s ./samples/k8s-cost-estimator-local/app-v1  \
    --config ./samples/k8s-cost-estimator-local/example-conf.yaml --v trace

In der Ausgabe wird eine Markdown-Tabelle mit den geschätzten monatlichen Kosten für den Ordner ./samples/k8s-cost-estimator-local/app-v1/ angezeigt. Um die monatlichen Produktionskosten ihrer Anwendungen besser zu verstehen, können Entwickler diesen Schritt ausführen, bevor sie eine Push-Übertragung zum Remote-Repository durchführen.

INFO[0000] Starting cost estimation (version v0.0.1)...
...

|         KIND          | MIN REQUESTED (USD) | MIN REQ + HPA CPU BUFFER (USD) | MAX REQUESTED (USD) | MIN LIMITED (USD) | MAX LIMITED (USD) |
|-----------------------|---------------------|--------------------------------|---------------------|-------------------|-------------------|
| Deployment            |             $133.31 |                        $198.71 |             $266.54 |           $312.83 |           $579.29 |
| StatefulSet           |              $36.33 |                         $36.33 |              $36.33 |            $72.67 |            $72.67 |
| DaemonSet             |              $29.68 |                         $29.68 |              $29.68 |            $53.19 |            $53.19 |
| PersistentVolumeClaim |              $28.88 |                         $28.88 |              $28.88 |            $33.68 |            $33.68 |
| **TOTAL**             |         **$228.20** |                    **$293.60** |         **$361.43** |       **$472.38** |       **$738.83** |

INFO[0002] Finished cost estimation!

Erstellen Sie das Kubernetes-Container-Image für die Kostenschätzung:

docker build . -t us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

Erstellen Sie das Artifact Registry-Docker-Repository zum Speichern des Images:

gcloud artifacts repositories create docker-repo \
        --repository-format=docker \
        --location=us-central1 \
        --description="Docker repository"

Registrieren Sie gcloud als Credential Helper für die Konfigurationsdatei von Docker. Wenn Sie dazu aufgefordert werden, bestätigen Sie die Dateiaktualisierung.
```
gcloud auth configure-docker us-central1-docker.pkg.dev
```

Übertragen Sie das Image per Push in Artifact Registry:

docker push us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

Neues GitHub-Repository erstellen

Wechseln Sie in Cloud Shell die Verzeichnisse wie im GitHub-Beispiel:
```
cd samples/k8s-cost-estimator-github
```
Erstellen Sie in GitHub ein Zugriffstoken:

Zur GitHub-Seite mit persönlichen Zugriffstokens
1. Geben Sie im Feld Hinweis eine Tokenbeschreibung ein.
2. Klicken Sie unter Bereiche auswählen auf die Kästchen repo, admin:public_key und delete_repo.
3. Klicken Sie auf Token generieren und kopieren Sie den Wert für Ihr neues persönliches Zugriffstoken oben auf der Seite.
Speichern Sie Ihr persönliches Zugriffstoken in Cloud Shell in einer Variablen.
```
GITHUB_TOKEN=YOUR_NEW_PERSONAL_ACCESS_TOKEN
```
Dabei gilt:
- YOUR_NEW_PERSONAL_ACCESS_TOKEN: das persönliche Zugriffstoken, das Sie gerade erstellt haben.

Erstellen Sie ein GitHub-Repository:

curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/repos \
  -d '{"name":"k8s-cost-estimator-github"}' | jq

Die Ausgabe sieht etwa so aus:

{
  "id": 36099474,
  "node_id": "MDEwOldfsdjA5OTQ3Njc=",
  "name": "k8s-cost-estimator-github",
  ...
}

Fügen Sie den FinOps-Prüfer als Mitbearbeiter in Ihrem Repository hinzu:

curl -X PUT \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github/collaborators/$GITHUB_FINOPS_REVIEWER_USER  | jq -r .html_url

Die Ausgabe sieht etwa so aus:

https://github.com/your-user/k8s-cost-estimator-github/invitations

Geben Sie die Ausgabe-URL für den Nutzer frei, den Sie in der Variable GITHUB_FINOPS_REVIEWER_USER festgelegt haben, damit er die Einladung annehmen kann. Bevor Sie mit dem nächsten Schritt fortfahren, rufen Sie dieselbe URL auf, um sicherzustellen, dass die Einladung akzeptiert wurde.

Verbinden Sie Cloud Build mit dem GitHub-Repository.

In diesem Abschnitt erfahren Sie, wie Sie die Cloud Build-GitHub-Anwendung installieren. Mit dieser Installation können Sie Ihr GitHub-Repository mit Ihrem Google Cloud-Projekt verbinden, sodass Cloud Build automatisch das Kubernetes-Schätzungstool bei jeder Pull-Anfrage ausführt.

Rufen Sie die GitHub Marketplace-Seite für die Cloud Build-Anwendung auf:

Cloud Build öffnen
Richten Sie den GitHub-Kontozugriff für die Anwendung ein:
1. Wenn Sie zum ersten Mal eine Anwendung in GitHub konfigurieren, klicken Sie unten auf der Seite auf Mit Google Cloud Build einrichten und dann auf Dieser Anwendung Zugriff auf GitHub-Konto gewähren.
2. Wenn Sie bereits eine Anwendung in GitHub eingerichtet haben, klicken Sie auf Zugriff konfigurieren.
Die Seite Anwendungen wird geöffnet. Führen Sie folgende Schritte aus:
1. Klicken Sie in der Zeile für Google Cloud Build auf Konfigurieren.
2. Wählen Sie die Option Nur Repositories auswählen aus.
3. Wählen Sie k8s-cost-estimator-github aus, um eine Verbindung zum soeben erstellten Repository herzustellen.
4. Klicken Sie auf Speichern oder Installieren (das Schaltflächenlabel ändert sich je nach ausgeführtem Ablauf).
Sie werden jetzt zu Google Cloud weitergeleitet, um die Installation fortzusetzen. Melden Sie sich mit Ihrem Google Cloud-Konto an. Autorisieren Sie die Cloud Build-Integration in GitHub, wenn Sie dazu aufgefordert werden.
Wählen Sie auf der Seite Cloud Build Ihr Projekt aus. Ein Assistent wird angezeigt.
Wählen Sie im Bereich Repository auswählen des Assistenten Ihr GitHub-Konto und das Repository k8s-cost-estimator-github aus.
Wenn Sie mit den Nutzungsbedingungen einverstanden sind, klicken Sie das Kästchen an und klicken Sie dann auf Verbinden.
Klicken Sie im Abschnitt Trigger erstellen auf Trigger erstellen und führen Sie die folgenden Schritte aus:
1. Geben Sie einen Triggernamen ein.
2. Wählen Sie im Abschnitt Ereignis die Option Pull-Anfrage (nur GitHub-App) aus.
3. Im Abschnitt Quelle:
  - Das Feld Repository ist automatisch mit your-github-user/k8s-cost-estimator-github (GitHub-App) gefüllt.
  - Wählen Sie im Drop-down-Menü Basis-Branch die Option .* aus.
4. Wählen Sie im Abschnitt Konfigurationstyp die Option Cloud Build-Konfigurationsdatei (YAML oder JSON) aus.
5. Fügen Sie im Bereich Erweitert die folgenden Substitutionsvariablen ein:
  - _GITHUB_TOKEN = YOUR_PERSONAL_ACCESS_TOKEN
  - _GITHUB_FINOPS_REVIEWER_USER = THE_GITHUB_FINOPS_REVIEWER_USER
  - _GITHUB_FINOPS_COST_USD_THRESHOLD = 10
  Dabei gilt:
  - YOUR_PERSONAL_ACCESS_TOKEN: das persönliche GitHub-Zugriffstoken, das Sie erstellt haben. Dieses Token ist in der Variable GITHUB_TOKEN in Cloud Shell verfügbar.
  - THE_GITHUB_FINOPS_REVIEWER_USER: der Nutzer, den Sie als Mitbearbeiter in Ihrem GitHub-Repository eingeladen haben. Dieser Nutzername ist in der Cloud Shell-Variable GITHUB_FINOPS_REVIEWER_USER verfügbar.
Klicken Sie auf Erstellen.

Die GitHub-Anwendung "Cloud Build" ist jetzt konfiguriert und Ihr GitHub-Repository ist mit Ihrem Google Cloud-Projekt verknüpft. Pull-Anfragen an Ihr GitHub-Repository lösen jetzt Cloud Build-Ausführungen aus, die die Ergebnisse mithilfe von GitHub-Prüfungen an GitHub zurückmelden.

Übertragen Sie den Beispielcode per Push in Ihr GitHub-Repository.

Erstellen Sie ein SSH-Schlüsselpaar, damit Sie den Beispielcode per Push in Ihr GitHub-Repository übertragen können:

mkdir -p ssh && cd ssh
ssh-keygen -t rsa -b 4096 -N '' -f github-key
eval `ssh-agent` && ssh-add $(pwd)/github-key
curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/keys \
  -d "{\"title\":\"k8s-cost-estimator-key\", \"key\":\"$(cat github-key.pub)\"}" | jq
cd ..

Die Ausgabe sieht etwa so aus:

{
  "id": 52356205,
  "key": "ssh-rsa AAAAB3NzaC….wJICyt0yvWjGFZGCWBPUw==",
  "url": "https://api.github.com/user/keys/526205",
  "title": "k8s-cost-estimator-key",
  "verified": true,
  "created_at": "2021-04-23T16:22:58Z",
  "read_only": false
}

Übertragen Sie den Inhalt per Push in Ihr neues GitHub-Repository:

sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITHUB_USER/$GITHUB_USER/g; s/GITHUB_EMAIL/$GITHUB_EMAIL/g;" templates/cloudbuild.yaml.tpl > cloudbuild.yaml

GITHUB_SSH_URL_REPO=$(curl -X GET \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github | jq -r .ssh_url)
[ -z "$GITHUB_SSH_URL_REPO" ] && echo "GITHUB_SSH_URL_REPO is not exported" || echo "GITHUB_SSH_URL_REPO is $GITHUB_SSH_URL_REPO"

git init
git remote add origin $GITHUB_SSH_URL_REPO
git add -A .
git commit -m "Initial commit"
git checkout -b main
git push -u origin main

Code ändern und Pull-Anfrage erstellen, um die Kostenschätzung zu testen

Rufen Sie in Cloud Shell die GitHub-URL zur Datei wordpress/wordpress_hpa.yaml ab:

echo "https://github.com/$GITHUB_USER/k8s-cost-estimator-github/edit/main/wordpress/wordpress_hpa.yaml"

Verwenden Sie Strg + Klick (Cmd + Klick für Mac-Nutzer) für die Ausgabe-URL, um GitHub aufzurufen und die Datei wordpress/wordpress_hpa.yaml zu bearbeiten.
Ändern Sie in GitHub minReplicas zu 5.
Wählen Sie Neuen Branch für diesen Commit erstellen und Pull-Anfrage starten aus und klicken Sie dann auf Änderungen vorschlagen.
Klicken Sie im Bildschirm Pull-Anfrage öffnen auf Pull-Anfrage erstellen.

Neben dem Erstellen einer neuen Pull-Anfrage löst dieser Schritt eine Cloud Build-Ausführung auf Basis der zuvor erstellten Datei cloudbuild.yaml aus. Diese Cloud Build-Ausführung verwendet das Container-Image, das Sie in Kubernetes-Kostenschätzungs-Image erstellen und per Push übertragen erstellt haben, und trifft die Entscheidung, wann ein FinOps-Prüfer erforderlich ist.
Warten Sie etwa eine Minute, bis die Pipeline abgeschlossen ist. Nach Abschluss des Vorgangs wird in der Pull-Anfrage ein Kommentar mit Kostendetails hinzugefügt. Da die Kostenerhöhung für den Code den Grenzwert von 10 $ überschritten hat, wird auch ein FinOps-Prüfer angefordert.

Die Ausgabe sieht etwa so aus:

Jetzt wissen Sie, wie Sie Ihren Entwicklern zu Beginn des Entwicklungszyklus einen Einblick in ihre Ausgaben geben können. Diese Konfiguration hilft Ihnen und Ihrer Organisation, Überraschungen auf Ihrer Google Cloud-Rechnung zu vermeiden.

Bereinigen

Um zu vermeiden, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden, können Sie Ihr Projekt löschen.

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

GitHub-Repository löschen

Wenn Sie Ihr GitHub-Repository nicht behalten möchten, gehen Sie so vor:

Löschen Sie in Cloud Shell Ihr GitHub-Repository:

curl -X DELETE \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github

Wenn die Verbindung zu Cloud Shell getrennt wird, müssen Sie die Variablen GITHUB_TOKEN und GITHUB_USER zurücksetzen.

Nächste Schritte

Wenn Sie GitLab verwenden, lesen Sie die Informationen unter GKE-Kosten am Anfang des Entwicklungszyklus mit GitLab schätzen.
Weitere Informationen zur GKE-Kostenoptimierung finden Sie unter Best Practices zum Ausführen kostenoptimierter Kubernetes-Anwendungen in GKE.
Designempfehlungen und Best Practices zur Optimierung der Kosten von Google Cloud-Arbeitslasten finden Sie unter Google Cloud-Architektur-Framework: Kostenoptimierung.
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center