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

In dieser Anleitung wird gezeigt, wie Sie die Kostensichtbarkeit von Google Kubernetes Engine (GKE) mit GitLab zu Ihrem Entwicklungsteam verschieben. Wenn Sie frühzeitig im Entwicklungsprozess auf die Kosten aufmerksam machen, können Sie Überraschungen auf Ihrer Google Cloud-Rechnung vermeiden. Das Verschieben einer Aufgabe oder von Informationen in einen früheren Teil eines Prozesses wird manchmal als Linksverschiebung bezeichnet.

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

Für diese Anleitung wird vorausgesetzt, dass Sie mit den folgenden Technologien 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 die Kultur der finanziellen Rechenschaftspflicht gefördert. Eine Best Practice von FinOps besteht darin, Teams in Echtzeit Informationen zu ihren Ausgaben bereitzustellen, damit sich Kostenprobleme sofort beheben lassen.

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 GitLab-Website hervorgehoben, ist Code Review eine wesentliche Vorgehensweise für jedes erfolgreiche Projekt und Ihre Genehmigung, sobald eine Anfrage zur Zusammenführung einen guten Zustand hat, ist ein wichtiger Bestandteil des Prüfungsprozesses. Die beste Zeit für eine Kostenschätzung ist daher 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, können Entwickler die GKE-Kosten in ihrer lokalen Umgebung schätzen, idealerweise bei der Erstellung. Mit dieser Schätzung erhalten sie ein Verständnis der monatlichen Kosten für die Produktionsarbeitslast. Wenn das Feature oder die Fehlerkorrektur abgeschlossen ist, können sie eine Zusammenführungsanfrage vorschlagen, die eine GitLab-CI/CD-Pipeline auslöst, um den Unterschied zwischen den alten und den neuen Kosten zu prüfen. Wenn Erhöhungen über einen vordefinierten Schwellenwert hinausgehen, fordert die Pipeline automatisch einen neuen Code Review an. 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 ein Kubernetes-Image für die Kostenschätzung und übertragen Sie es per Push.
Erstellen Sie ein neues GitLab-Projekt.
Konfigurieren Sie GitLab-Runner zur Ausführung in einem GKE-Cluster.
Übertragen Sie den Beispielcode per Push in Ihr GitLab-Repository.
Ändern Sie den Code und schlagen Sie eine Zusammenführungsanfrage 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 die Kostenschätzung implementiert.
- api/: enthält die Go 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 Cloud-Projekt-ID sowie Ihr GitLab-Nutzerkonto und Ihre E-Mail-Adresse fest:

export GCP_PROJECT_ID=YOUR_PROJECT_ID
export GITLAB_USER=YOUR_GITLAB_USER
export GITLAB_EMAIL=YOUR_GITLAB_EMAIL_ADDRESS

gcloud config set project $GCP_PROJECT_ID

gcloud services enable cloudbilling.googleapis.com \
    compute.googleapis.com \
    container.googleapis.com \
    iamcredentials.googleapis.com \
    artifactregistry.googleapis.com

gcloud config set compute/region us-central1
gcloud config set compute/zone us-central1-f

Dabei gilt:

YOUR_PROJECT_ID : die Cloud-Projekt-ID des Projekts, das Sie in dieser Anleitung verwenden
YOUR_GITLAB_USER : das Nutzerkonto, mit dem Sie sich in Ihrem GitLab-Konto anmelden
YOUR_GITLAB_EMAIL_ADDRESS: die E-Mail-Adresse, die Sie in Ihrem GitLab-Konto verwenden

Optional können Sie für diese Anleitung eine andere Region und Zone verwenden.

Kubernetes-Kostenschätzungs-Image erstellen und per Push übertragen

Das in dieser Anleitung enthaltene Kubernetes-Kostenschätzungs-Tool ist ein Beispiel dafür, was möglich ist. Es 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 Code per Push zum Remote-Repository übertragen.

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 Docker-Konfigurationsdatei.
```
gcloud auth configure-docker us-central1-docker.pkg.dev
```
Wenn Sie dazu aufgefordert werden, bestätigen Sie die Dateiaktualisierung.

Übertragen Sie das Image per Push an Artifact Registry.

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

Neues GitLab-Projekt erstellen

Wechseln Sie in Cloud Shell zum Verzeichnis des GitLab-Beispiels:
```
cd samples/k8s-cost-estimator-gitlab
```
Erstellen Sie auf der GitLab-Seite Persönliche Zugriffstokens ein Zugriffstoken:

Zur GitLab-Seite für persönliche Zugriffstokens
1. Geben Sie im Feld Name den Namen für das Token ein, das Sie erstellen.
2. Wählen Sie im Feld Bereich die Option api aus und klicken Sie dann auf Persönliches Zugriffstoken erstellen.
3. Kopieren Sie den Wert für Mein neues persönliches Zugriffstoken.
Speichern Sie Ihr persönliches Zugriffstoken in Cloud Shell in einer Variablen:
```
GITLAB_API_TOKEN=YOUR_NEW_PERSONAL_ACCESS_TOKEN
```
Dabei gilt:
- YOUR_NEW_PERSONAL_ACCESS_TOKEN: das persönliche GitLab-Zugriffstoken, das Sie erstellt haben.

Erstellen Sie ein neues GitLab-Projekt:

GITLAB_PROJECT_OUTPUT=$(curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d '{"name":"k8s-cost-estimator-gitlab","visibility":"public"}'        https://gitlab.com/api/v4/projects)
GITLAB_PROJECT_ID=$(echo $GITLAB_PROJECT_OUTPUT | jq ".id")
GITLAB_FINOPS_REVIEWER_ID=$(echo $GITLAB_PROJECT_OUTPUT | jq ".owner.id")

Legen Sie die Variablen für das Tool zur Kostenschätzung fest, die beim Erstellen einer Zusammenführungsanfrage verwendet werden sollen:

curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d "{\"key\": \"GITLAB_API_TOKEN\",\"value\": \"$GITLAB_API_TOKEN\", \"masked\":\"true\"}" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables

curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d "{\"key\": \"GITLAB_FINOPS_REVIEWER_ID\",\"value\": \"$GITLAB_FINOPS_REVIEWER_ID\"}" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables

curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d "{\"key\": \"GITLAB_FINOPS_COST_USD_THRESHOLD\",\"value\": \"10\"}" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables

Prüfen Sie, ob Ihr Projekt und Ihre Variablen erstellt wurden:
```
curl -s --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" \
https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables | jq
```
Die Ausgabe sollte so aussehen:
```
[
  {
    "variable_type": "env_var",
    "key": "GITLAB_API_TOKEN",
    "value": "Ex...n1",
    "protected": false,
    "masked": true,
    "environment_scope": "*"
  },
  {
    "variable_type": "env_var",
    "key": "GITLAB_FINOPS_REVIEWER_ID",
    "value": "88..87",
    "protected": false,
    "masked": false,
    "environment_scope": "*"
  },
  {
    "variable_type": "env_var",
    "key": "GITLAB_FINOPS_COST_USD_THRESHOLD",
    "value": "10",
    "protected": false,
    "masked": false,
    "environment_scope": "*"
  }
]
```
Die in Ihrem GitLab-Projekt konfigurierten Variablen werden von der Datei ./samples/k8s-cost-estimator-gitlab/templates/.gitlab-ci.yml.tpl verwendet, um Zusammenführungsanfragen zu aktualisieren, und sind folgende:
- GITLAB_API_TOKEN: Ihr persönliches GitLab-Zugriffstoken.
- GITLAB_FINOPS_REVIEWER_ID: Der Codeprüfer ist erforderlich, wenn die Kosten einen bestimmten Schwellenwert überschreiten. Der Einfachheit halber wird in dieser Anleitung Ihre eigene Nutzer-ID als Prüfer festgelegt. In einer Produktionsumgebung empfehlen wir jedoch, statt einer einzelnen Person ein Team zu konfigurieren.
- GITLAB_FINOPS_COST_USD_THRESHOLD: Der Schwellenwert in USD, in diesem Fall 10 $. Wenn die Differenz zwischen alten und neuen Kosten diesen Schwellenwert überschreitet, wird eine außergewöhnliche Genehmigung erzwungen. Sie können auch Schwellenwerte für andere Werte festlegen. Zum Ausprobieren dieses Features können Sie den Parameter --output anhängen, wenn Sie den Befehl ./bin/k8s-cost-estimator unter Kubernetes-Kostenschätzungs-Image erstellen und per Push übertragen ausführen. Dieser Parameter generiert eine Datei mit der Endung .diff, mit der Sie die verfügbaren Optionen anzeigen können.

GitLab-Runner für die Ausführung in einem GKE-Cluster konfigurieren

In diesem Abschnitt installieren Sie den GitLab-Runner in Ihrem eigenen GKE-Cluster mit Workload Identity, damit das Kubernetes-Schätzungs-Tool den Google Cloud-Preiskatalog abfragen kann. Das Schätzungs-Tool verwendet Bruttopreise und berücksichtigt keine VMs auf Abruf oder Rabatte.

Erstellen Sie in Cloud Shell einen GKE-Cluster:

gcloud beta container clusters create gitlab-runners \
    --enable-ip-alias \
    --release-channel=stable \
    --workload-pool=$GCP_PROJECT_ID.svc.id.goog \
    --enable-autoprovisioning --min-cpu 1 --min-memory 1 --max-cpu 4 --max-memory 16 \
    --autoscaling-profile=optimize-utilization \
    --preemptible

Rufen Sie das Registrierungstoken für den GitLab-Runner aus dem von Ihnen erstellten Projekt ab:

export GITLAB_RUNNER_TOKEN=$(curl -s --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID | jq -r '.runners_token')
[ -z "$GITLAB_RUNNER_TOKEN" ] && echo "GITLAB_RUNNER_TOKEN is not exported" || echo "GITLAB_RUNNER_TOKEN is $GITLAB_RUNNER_TOKEN"

Installieren Sie den GitLab-Runner in Ihrem GKE-Cluster:

kubectl create namespace gitlab

helm repo add gitlab https://charts.gitlab.io

sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITLAB_RUNNER_TOKEN/$GITLAB_RUNNER_TOKEN/g" templates/gitlab-runner-values.yaml.tpl > gitlab-runner-values.yaml

helm install --namespace gitlab --version 0.24.0 gitlab-runner -f gitlab-runner-values.yaml gitlab/gitlab-runner

kubectl -n gitlab wait --for=condition=available deployment gitlab-runner --timeout=5m

gcloud iam service-accounts create gitlab-runner --display-name=gitlab-runner
gcloud iam service-accounts add-iam-policy-binding \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:$GCP_PROJECT_ID.svc.id.goog[gitlab/gitlab-runner]" \
    gitlab-runner@$GCP_PROJECT_ID.iam.gserviceaccount.com

Deaktivieren Sie freigegebene Runner in Ihrem GitLab-Projekt:

curl -s --header "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" -X PUT "https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID" --form "shared_runners_enabled=false"

Prüfen Sie, ob der von Ihnen bereitgestellte Runner in Ihrem GitLab-Projekt aktiviert ist:

curl -s --header "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" "https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/runners?status=active" | jq '.[] | select(.is_shared==false)'

Die Ausgabe sollte so aussehen:

{
    "id": 49345561,
    "description": "gitlab-runner-gitlab-runner-788459d488-jlscn",
    "ip_address": "35.178.223.199",
    "active": true,
    "is_shared": false,
    "name": "gitlab-runner",
    "online": true,
    "status": "online"
}

Beispielcode per Push in das GitLab-Repository übertragen

Erstellen Sie ein SSH-Schlüsselpaar, um den Beispielcode per Push in Ihr GitLab-Repository zu übertragen:

mkdir -p ssh && cd ssh
ssh-keygen -t rsa -b 4096 -N '' -f gitlab-key
eval `ssh-agent` && ssh-add $(pwd)/gitlab-key
curl -s --request POST --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/user/keys --form "title=k8s-cost-estimator-key" --form "key=$(cat gitlab-key.pub)"
cd ..

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

sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITLAB_USER/$GITLAB_USER/g; s/GITLAB_EMAIL/$GITLAB_EMAIL/g;" templates/.gitlab-ci.yml.tpl > .gitlab-ci.yml

GITLAB_SSH_URL_REPO=$(curl -s --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/users/$GITLAB_FINOPS_REVIEWER_ID/projects | jq '.[] | select(.name=="k8s-cost-estimator-gitlab")' | jq -r '.ssh_url_to_repo')
[ -z "$GITLAB_SSH_URL_REPO" ] && echo "GITLAB_PROJECT_SSH_URL is not exported" || echo "GITLAB_PROJECT_SSH_URL is $GITLAB_SSH_URL_REPO"

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

Code ändern und Zusammenführungsanfrage vorschlagen, um die Kostenschätzung in Aktion zu sehen

Rufen Sie in Cloud Shell die URL für die GitLab-Web-IDE (integrierte Entwicklungsumgebung) ab:

echo "https://gitlab.com/-/ide/project/$GITLAB_USER/k8s-cost-estimator-gitlab/tree/main/-/wordpress/wordpress_hpa.yaml"

Klicken Sie bei gedrückter Strg-Taste (Befehlstaste + Klick unter macOS) auf die Ausgabe-URL, um zur GitLab-Web-IDE zu wechseln.
Bearbeiten Sie in der GitLab-Web-IDE die Datei ./wordpress/wordpress_hpa.yaml so:
1. Ändern Sie den Wert minReplicas von 2 in 5.
2. Klicken Sie auf Commit.
Wählen Sie wie im folgenden Screenshot gezeigt Neuen Zweig erstellen und Neue Zusammenführungsanfrage starten aus. Klicken Sie dann auf Commit.
Klicken Sie auf dem Bildschirm Neue Zusammenführungsanfrage unten auf der Seite auf Zusammenführungsanfrage erstellen.

Neben dem Erstellen einer neuen Zusammenführungsanfrage löst dieser Schritt eine Pipeline zur Kostenschätzung anhand der Datei .gitlab-ci.yml aus. Diese Pipeline verwendet das Container-Image, das Sie in einem vorherigen Abschnitt erstellt haben. Diese Pipeline bestimmt auch, wann eine FinOps-Genehmigung erforderlich ist. Zur Vereinfachung fügt .gitlab-ci.yml für jede Basis einer Zusammenführungsanfrage Genehmigungen hinzu. Sie können jedoch auf GitLab-Projektebene definierte Genehmigungsregeln definieren und wiederverwenden.
Warten Sie etwa eine Minute, bis die Pipeline abgeschlossen ist. Nach Abschluss wird ein Kommentar mit Kostendetails in der Zusammenführungsanfrage hinzugefügt. Da die Kostenerhöhung für den vorgeschlagenen Code den Schwellenwert von 10 $ überschreitet, wird auch ein FinOps-Prüfer angefordert.

Die Ausgabe sollte so aussehen:

In dieser Anleitung wird die Standardkonfiguration für Genehmigungen von Zusammenführungsanfragen verwendet. Es ist möglich, verschiedene Konfigurationen für Zusammenführungsanfragen in Gitlab auszuwählen. Wenn Sie beispielsweise verhindern möchten, dass der Autor Zusammenführungsanfragen genehmigt, rufen Sie Einstellungen > Allgemein > Genehmigungen von Zusammenführungsanfragen > Genehmigungseinstellungen auf.

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.

GitLab-Projekt löschen

Wenn Sie Ihr GitLab-Projekt nicht behalten möchten, gehen Sie so vor:

Löschen Sie in Cloud Shell Ihr GitLab-Projekt:
```
 curl -X DELETE -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID
```
Die Ausgabe sollte so aussehen: {"message":"202 Accepted"}

Wenn Sie die Verbindung zu Cloud Shell verlieren, müssen Sie die folgenden Variablen noch einmal festlegen:
- GITLAB_API_TOKEN
- GITLAB_PROJECT_ID

Nächste Schritte

Weitere Informationen zur GKE-Kostenoptimierung finden Sie unter Best Practices zum Ausführen kostenoptimierter Kubernetes-Anwendungen in GKE.
Informationen zum Monitoring Ihres GKE-Clusters und Ihrer Anwendungen finden Sie unter GKE-Cluster mit Cloud Monitoring in Bezug auf die Kostenoptimierung beobachten.
GKE-Kosten am Anfang des Entwicklungszyklus mit GitHub schätzen
Weitere Tipps und Best Practices zur Optimierung der GKE-Kosten unter Kostenoptimierung in Google Cloud für Entwickler und Operatoren erhalten
Referenzarchitekturen, Diagramme, Anleitungen und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center