Kurzanleitung: Sprachspezifische Anwendungen bereitstellen

Diese Seite enthält Anleitungen für Folgendes:

  1. Eine Hello-World-Anwendung erstellen.
  2. Die Anwendung mit Cloud Build in einem Container-Image verpacken.
  3. Einen Cluster in Google Kubernetes Engine (GKE) erstellen.
  4. Das Container-Image in Ihrem Cluster bereitstellen.

Es wird gezeigt, wie Sie das Beispiel mit verschiedenen Sprachen ausführen können. Sie können es jedoch auch mit Sprachen ausführen, die hier nicht behandelt werden.


Eine detaillierte Anleitung zu dieser Aufgabe finden Sie direkt im Cloud Shell-Editor. Klicken Sie dazu einfach auf Anleitung:

Anleitung


Die folgenden Abschnitte führen Sie durch dieselben Schritte wie das Klicken auf Anleitung.

Hinweis

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Cloud Build and Google Kubernetes Engine APIs aktivieren.

    Aktivieren Sie die APIs

  5. Installieren und initialisieren Sie das Cloud SDK.
  6. kubectl wird zur Verwaltung von Kubernetes verwendet, dem Cluster-Orchestrierungssystem von GKE. Sie können kubectl mithilfe von gcloud installieren:
    gcloud components install kubectl

Beispielanwendung schreiben

Eine Anleitung zum Erstellen einer Hello-World-Anwendung, die auf GKE ausgeführt wird, erhalten Sie, wenn Sie auf Ihre Sprache klicken:

Go

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie ein neues Modul namens example.com/helloworld:

    go mod init example.com/helloworld
    
  3. Erstellen Sie eine neue Datei mit dem Namen helloworld.go und fügen Sie den folgenden Code in diese ein:

    package main
    
    import (
    	"fmt"
    	"log"
    	"net/http"
    	"os"
    )
    
    func main() {
    	http.HandleFunc("/", handler)
    
    	port := os.Getenv("PORT")
    	if port == "" {
    		port = "8080"
    	}
    
    	log.Printf("Listening on localhost:%s", port)
    	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
    }
    
    func handler(w http.ResponseWriter, r *http.Request) {
    	log.Print("Hello world received a request.")
    	target := os.Getenv("TARGET")
    	if target == "" {
    		target = "World"
    	}
    	fmt.Fprintf(w, "Hello %s!\n", target)
    }
    

    Mit diesem Code wird ein Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einem Docker-Container verpackt und dann in Container Registry hochgeladen werden.

Node.js

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und wechseln Sie dorthin:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie eine package.json-Datei mit folgendem Inhalt:

    {
      "name": "gke-helloworld",
      "version": "1.0.0",
      "description": "GKE hello world sample in Node",
      "main": "index.js",
      "scripts": {
        "start": "node index.js"
      },
      "author": "",
      "license": "Apache-2.0",
      "dependencies": {
        "express": "^4.16.4"
      }
    }
    
  3. Erstellen Sie im selben Verzeichnis eine index.js-Datei und kopieren Sie die folgenden Zeilen hinein:

    const express = require('express');
    const app = express();
    
    app.get('/', (req, res) => {
      console.log('Hello world received a request.');
    
      const target = process.env.TARGET || 'World';
      res.send(`Hello ${target}!`);
    });
    
    const port = process.env.PORT || 8080;
    app.listen(port, () => {
      console.log('Hello world listening on port', port);
    });
    

    Mit diesem Code wird ein Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einem Docker-Container verpackt und in Container Registry hochgeladen werden.

Python

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und wechseln Sie dorthin:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie eine Datei mit dem Namen app.py und fügen Sie dort den folgenden Code ein:

    import os
    
    from flask import Flask
    
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        target = os.environ.get('TARGET', 'World')
        return 'Hello {}!\n'.format(target)
    
    if __name__ == "__main__":
        app.run(debug=True,host='0.0.0.0',port=int(os.environ.get('PORT', 8080)))
    

Java

Erstellen Sie eine Spring Boot-Anwendung.

  1. Installieren Sie das Java SE Development Kit Version 8 oder höher und cURL. Java SE und cURL sind nur erforderlich, um das neue Webprojekt im nächsten Schritt zu erstellen. Das weiter unten beschriebene Dockerfile lädt alle Abhängigkeiten in den Container.

  2. Erstellen Sie über Ihr Terminal ein neues, leeres Webprojekt:

    curl https://start.spring.io/starter.zip \
        -d dependencies=web \
        -d javaVersion=1.8 \
        -d bootVersion=2.1.3.RELEASE \
        -d name=helloworld \
        -d artifactId=helloworld \
        -d baseDir=helloworld-gke \
        -o helloworld-gke.zip
    unzip helloworld-gke.zip
    cd helloworld-gke
    

    Sie haben jetzt ein neues Spring Boot-Projekt in helloworld-gke.

  3. Aktualisieren Sie in der Datei src/main/java/com/example/helloworld/HelloworldApplication.java die Klasse HelloworldApplication durch Hinzufügen eines @RestController zur Verarbeitung der /-Zuordnung.

    package com.example.helloworld;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @SpringBootApplication
    public class HelloworldApplication {
    
    	@Value("${TARGET:World}")
    	String target;
    
    	@RestController
    	class HelloworldController {
    		@GetMapping("/")
    		String hello() {
    			return "Hello " + target + "!";
    		}
    	}
    
    	public static void main(String[] args) {
    		SpringApplication.run(HelloworldApplication.class, args);
    	}
    }
    

    Mit diesem Code wird ein Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einem Docker-Container verpackt und dann in Container Registry hochgeladen werden.

C#

  1. Installieren Sie das .NET Core SDK 2.2. Das .NET Core SDK ist nur zum Erstellen des neuen Webprojekts im nächsten Schritt erforderlich. Der weiter unten beschriebene Dockerfile lädt alle Abhängigkeiten in den Container.

  2. Erstellen Sie über Ihr Terminal ein neues, leeres Webprojekt:

    dotnet new web -o helloworld-gke
    
  3. Ändern Sie das Verzeichnis in helloworld-gke.

  4. Aktualisieren Sie die Definition CreateWebHostBuilder in Program.cs. Dazu geben Sie die Port-URL für .UseUrls() an, um den Bereitstellungsport zu definieren. Im Beispiel wurde Port 8080 verwendet, aber Sie können auch andere Ports verwenden. Ihr Server muss den hier angegebenen Port überwachen:

    // Copyright (c) 2019 Google LLC.
    //
    // Licensed under the Apache License, Version 2.0 (the "License"); you may not
    // use this file except in compliance with the License. You may obtain a copy of
    // the License at
    //
    // http://www.apache.org/licenses/LICENSE-2.0
    //
    // Unless required by applicable law or agreed to in writing, software
    // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    // License for the specific language governing permissions and limitations under
    // the License.
    
    using System;
    using Microsoft.AspNetCore;
    using Microsoft.AspNetCore.Hosting;
    
    namespace HelloGKE
    {
        public class Program
        {
            public static void Main(string[] args)
            {
                CreateWebHostBuilder(args).Build().Run();
            }
    
            public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
                WebHost.CreateDefaultBuilder(args)
                    .UseStartup<Startup>()
                    .UsePortEnvironmentVariable();
        }
    
        static class ProgramExtensions
        {
            // Google Cloud Run sets the PORT environment variable to tell this
            // process which port to listen to.
            public static IWebHostBuilder UsePortEnvironmentVariable(
                this IWebHostBuilder builder)
            {
                string port = Environment.GetEnvironmentVariable("PORT");
                if (!string.IsNullOrEmpty(port))
                {
                    builder.UseUrls($"http://0.0.0.0:{port}");
                }
                return builder;
            }
        }
    }
    

Die Anwendung ist jetzt fertig und kann in einem Docker-Container verpackt und dann in Container Registry hochgeladen werden.

PHP

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und wechseln Sie dorthin:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie eine Datei mit dem Namen index.php und fügen Sie dort den folgenden Code ein:

    <?php
    $target = getenv('TARGET', true) ?: 'World';
    echo sprintf("Hello %s!", $target);
    

Die Anwendung ist jetzt fertig und kann in einem Docker-Container verpackt und dann in Container Registry hochgeladen werden.

Ruby

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und wechseln Sie dorthin:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie eine Datei mit dem Namen app.rb und fügen Sie dort den folgenden Code ein:

    require 'sinatra'
    
    set :bind, '0.0.0.0'
    set :port, ENV['PORT'] || '8080'
    
    get '/' do
      target = ENV['TARGET'] || 'World'
      "Hello #{target}!\n"
    end
    

    Mit diesem Code wird ein Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

  3. Erstellen Sie eine Datei namens Gemfile und kopieren Sie Folgendes hinein:

    source 'https://rubygems.org'
    
    gem 'sinatra'
    gem 'rack', '>= 2.0.6'
    

Anwendung mit Cloud Build containerisieren

  1. Erstellen Sie zum Containerisieren der Beispielanwendung in dem Verzeichnis, in dem sich die Quelldateien befinden, eine neue Datei namens Dockerfile und kopieren Sie den folgenden Inhalt hinein:

    Go

    # Use the offical Golang image to create a build artifact.
    # This is based on Debian and sets the GOPATH to /go.
    # https://hub.docker.com/_/golang
    FROM golang:1.12 as builder
    
    # Copy local code to the container image.
    WORKDIR /app
    COPY . .
    
    # Build the command inside the container.
    RUN CGO_ENABLED=0 GOOS=linux go build -v -o helloworld
    
    # Use a Docker multi-stage build to create a lean production image.
    # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
    FROM alpine
    RUN apk add --no-cache ca-certificates
    
    # Copy the binary to the production image from the builder stage.
    COPY --from=builder /app/helloworld /helloworld
    
    # Run the web service on container startup.
    CMD ["/helloworld"]
    

    Node.js

    # Use the official lightweight Node.js 10 image.
    # https://hub.docker.com/_/node
    FROM node:10-slim
    
    # Create and change to the app directory.
    WORKDIR /usr/src/app
    
    # Copy application dependency manifests to the container image.
    # A wildcard is used to ensure both package.json AND package-lock.json are copied.
    # Copying this separately prevents re-running npm install on every code change.
    COPY package*.json ./
    
    # Install production dependencies.
    RUN npm install --only=production
    
    # Copy local code to the container image.
    COPY . ./
    
    # Run the web service on container startup.
    CMD [ "npm", "start" ]
    

    Fügen Sie eine weitere .dockerignore-Datei hinzu, um dafür zu sorgen, dass lokale Dateien keine Auswirkungen auf den Build-Prozess des Containers haben:

    Dockerfile
    README.md
    node_modules
    npm-debug.log
    

    Python

    # Use the official lightweight Python image.
    # https://hub.docker.com/_/python
    FROM python:3.7-slim
    
    # Copy local code to the container image.
    ENV APP_HOME /app
    WORKDIR $APP_HOME
    COPY . ./
    
    # Install production dependencies.
    RUN pip install Flask gunicorn
    
    # Run the web service on container startup. Here we use the gunicorn
    # webserver, with one worker process and 8 threads.
    # For environments with multiple CPU cores, increase the number of workers
    # to be equal to the cores available.
    CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 app:app
    

    Fügen Sie eine .dockerignore-Datei hinzu, um dafür zu sorgen, dass lokale Dateien keine Auswirkungen auf den Build-Prozess des Containers haben:

    Dockerfile
    README.md
    *.pyc
    *.pyo
    *.pyd
    __pycache__
    

    Java

    # Use the official maven/Java 8 image to create a build artifact.
    # https://hub.docker.com/_/maven
    FROM maven:3.5-jdk-8-alpine as builder
    
    # Copy local code to the container image.
    WORKDIR /app
    COPY pom.xml ./
    COPY src ./src/
    
    # Build a release artifact.
    RUN mvn package -DskipTests
    
    # Use AdoptOpenJDK for base image.
    # It's important to use OpenJDK 8u191 or above that has container support enabled.
    # https://hub.docker.com/r/adoptopenjdk/openjdk8
    # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
    FROM adoptopenjdk/openjdk8:jdk8u202-b08-alpine-slim
    
    # Copy the jar to the production image from the builder stage.
    COPY --from=builder /app/target/helloworld-*.jar /helloworld.jar
    
    # Run the web service on container startup.
    CMD ["java","-Djava.security.egd=file:/dev/./urandom","-Dserver.port=${PORT}","-jar","/helloworld.jar"]
    

    C#

    # Use Microsoft's official lightweight .NET images.
    # https://hub.docker.com/r/microsoft/dotnet
    
    FROM mcr.microsoft.com/dotnet/core/sdk:2.2-alpine AS build
    WORKDIR /app
    
    # Install production dependencies.
    # Copy csproj and restore as distinct layers.
    COPY *.csproj ./
    RUN dotnet restore
    
    # Copy local code to the container image.
    COPY . ./
    
    # Build a release artifact.
    RUN dotnet publish -c Release -o out
    
    # Run the web service on container startup in a lean production image.
    FROM mcr.microsoft.com/dotnet/core/aspnet:2.2-alpine
    WORKDIR /app
    
    COPY --from=build /app/out ./
    CMD ["dotnet", "HelloGKE.dll"]
    

    Fügen Sie eine .dockerignore-Datei hinzu, um dafür zu sorgen, dass lokale Dateien keine Auswirkungen auf den Build-Prozess des Containers haben:

    Dockerfile
    README.md
    **/obj/
    **/bin/
    

    PHP

    # Use the official PHP 7.4 image.
    # https://hub.docker.com/_/php
    FROM php:7.4-apache
    
    # Copy local code to the container image.
    COPY index.php /var/www/html/
    
    # Use port 8080 in Apache configuration files.
    RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf
    
    # Configure PHP for development.
    # Switch to the production php.ini for production operations.
    # RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
    # https://hub.docker.com/_/php#configuration
    RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"
    

    Fügen Sie eine .dockerignore-Datei hinzu, um dafür zu sorgen, dass lokale Dateien keine Auswirkungen auf den Build-Prozess des Containers haben:

    Dockerfile
    README.md
    vendor
    

    Ruby

    # Use the official lightweight Ruby image.
    # https://hub.docker.com/_/ruby
    FROM ruby:2.5-slim
    
    # Install production dependencies.
    WORKDIR /usr/src/app
    COPY Gemfile ./
    RUN bundle install
    
    # Copy local code to the container image.
    COPY . ./
    
    # Run the web service on container startup.
    CMD ["ruby", "./app.rb"]
    

  2. Rufen Sie Ihre Google Cloud-Projekt-ID ab:

    gcloud config get-value project
    

    Erstellen Sie das Container-Image mithilfe von Cloud Build. Dies ähnelt dem Ausführen von docker build und docker push, der Build wird aber in Google Cloud ausgeführt. Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-ID:

    gcloud builds submit --tag gcr.io/PROJECT_ID/helloworld-gke .
    

    Das Image wird in Container Registry gespeichert.

GKE-Cluster erstellen

Ein GKE-Cluster ist ein verwalteter Satz von Compute Engine-VMs, die als ein GKE-Cluster genutzt werden. Je nachdem, welchen Betriebsmodus Sie in GKE verwenden möchten, geben Sie beim Erstellen eines Clusters eine Standardzone oder -region an. Wenn Sie den Standardmodus verwenden, ist Ihr Cluster für diese Anleitung zonal. Legen Sie dann die Standard-Computing-Zone fest. Wenn Sie den Autopilot-Modus verwenden, ist Ihr Cluster regional. Legen Sie dann die Standard-Computing-Region fest.

  1. Erstellen Sie den Cluster.

    Standard

    Ersetzen Sie COMPUTE_ZONE durch die Google Cloud-Zone, in der Sie den Cluster hosten möchten, z. B. us-west1-a:

    gcloud container clusters create helloworld-gke \
        --num-nodes 1 \
        --zone COMPUTE_ZONE
    

    Autopilot

    Ersetzen Sie COMPUTE_REGION durch die Google Cloud-Region, in der Sie den Cluster hosten möchten, z. B. us-west1:

     gcloud container clusters create-auto helloworld-gke \
        --region COMPUTE_REGION
    
  2. Prüfen Sie, ob Sie auf den Cluster zugreifen können. Mit dem folgenden Befehl werden die Knoten aufgelistet, die in Ihrem Containercluster ausgeführt werden, und es wird angegeben, dass Sie Zugriff auf den Cluster haben.

    kubectl get nodes
    

    Falls Fehler auftreten, lesen Sie die Anleitung zur Fehlerbehebung in Kubernetes.

In GKE bereitstellen

Für die Bereitstellung Ihrer Anwendung in dem von Ihnen erstellten GKE-Cluster benötigen Sie zwei Kubernetes-Objekte.

  1. Ein Deployment zur Definition Ihrer Anwendung.
  2. Einen Service zum Festlegen des Zugriffs auf Ihre Anwendung.

Anwendung bereitstellen

Die Anwendung umfasst einen Front-End-Server, der die Webanfragen verarbeitet. Sie definieren die Clusterressourcen, die zum Ausführen des Front-Ends benötigt werden, in einer neuen Datei namens deployment.yaml. Diese Ressourcen werden als Deployment bezeichnet. Sie können mithilfe von Deployments ein ReplicaSet einschließlich der zugehörigen Pods erstellen und aktualisieren.

  1. Erstellen Sie die Datei deployment.yaml im selben Verzeichnis wie Ihre anderen Dateien und kopieren Sie den folgenden Inhalt, wobei Sie $GCLOUD_PROJECT durch Ihre Google Cloud-Projekt-ID ersetzen:

    # This file configures the hello-world app which serves public web traffic.
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: helloworld-gke
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: hello
      template:
        metadata:
          labels:
            app: hello
        spec:
          containers:
          - name: hello-app
            # Replace $GCLOUD_PROJECT with your project ID
            image: gcr.io/$GCLOUD_PROJECT/helloworld-gke:latest
            # This app listens on port 8080 for web traffic by default.
            ports:
            - containerPort: 8080
            env:
              - name: PORT
                value: "8080"
    
  2. Stellen Sie die Ressource im Cluster bereit:

    kubectl apply -f deployment.yaml
    
  3. Verfolgen Sie den Status des Deployments:

    kubectl get deployments
    

    Das Deployment ist abgeschlossen, wenn alle verfügbaren (AVAILABLE) Deployments den Status READY haben.

    NAME               READY   UP-TO-DATE   AVAILABLE   AGE
    hello-deployment   1/1     1            1           20s
    

    Wenn das Deployment einen Fehler hat, führen Sie kubectl apply -f deployment.yaml noch einmal aus, um das Deployment mit allen Änderungen zu aktualisieren.

  4. Wenn das Deployment abgeschlossen ist, können Sie die darin erstellten Pods sehen:

    kubectl get pods
    

Service bereitstellen

Services bieten einen zentralen Zugriffspunkt auf eine Reihe von Pods. Es ist grundsätzlich möglich, auf einen einzelnen Pod zuzugreifen. Pods sind jedoch sitzungsspezifisch und können zuverlässig nur über eine Service-Adresse aufgerufen werden. In Ihrer Hello World-Anwendung definiert der „hello“-Service einen Load-Balancer, mit dem über eine einzelne IP-Adresse auf die hello-app-Pods zugegriffen werden kann. Dieser Service ist in der Datei service.yaml definiert.

  1. Erstellen Sie die Datei service.yaml im selben Verzeichnis, in dem sich Ihre anderen Quelldateien befinden, mit folgendem Inhalt:

    # The hello service provides a load-balancing proxy over the hello-app
    # pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
    # create an external HTTP load balancer.
    apiVersion: v1
    kind: Service
    metadata:
      name: hello
    spec:
      type: LoadBalancer
      selector:
        app: hello
      ports:
      - port: 80
        targetPort: 8080
    

    Die Pods werden getrennt von dem Service definiert, der die Pods verwendet. Kubernetes nutzt Labels zur Auswahl der Pods für einen Service. Mit Labels kann ein Dienst Pods von verschiedenen Replikatsätzen verwenden. Gleichzeitig besteht mit Labels die Möglichkeit, dass mehrere Dienste einen einzelnen Pod nutzen.

  2. Erstellen Sie den Hello-World-Service:

    kubectl apply -f service.yaml
    
  3. Suchen Sie die externe IP-Adresse des Dienstes :

    kubectl get services
    

    Es kann bis zu 60 Sekunden dauern, bis die IP-Adresse zugeordnet ist. Die externe IP-Adresse wird unter der Spalte EXTERNAL-IP für den hello-Service aufgelistet.

    NAME         TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)        AGE
    hello        LoadBalancer   10.22.222.222   35.111.111.11   80:32341/TCP   1m
    kubernetes   ClusterIP      10.22.222.1     <none>          443/TCP        20m
    

Bereitgestellte Anwendung ansehen

Sie haben jetzt alle Ressourcen bereitgestellt, die zum Ausführen der Hello-World-Anwendung in GKE erforderlich sind.

Laden Sie die Anwendung mit der externen IP-Adresse aus dem vorherigen Schritt in den Webbrowser und sehen Sie sich Ihre laufende Anwendung an!

 http://EXTERNAL_IP

Sie können auch einen curl-Aufruf an die externe IP-Adresse des Dienstes ausführen:

curl EXTERNAL_IP

Die Ausgabe sieht so aus:

Hello World!

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Kurzanleitung verwendeten Ressourcen in Rechnung gestellt werden:

Ihnen werden Gebühren für die Compute Engine-Instanzen, die in Ihrem Cluster ausgeführt werden, sowie für das Container-Image in Container Registry berechnet.

Projekt löschen

Durch das Löschen des Cloudprojekts wird die Abrechnung für alle in diesem Projekt verwendeten Ressourcen beendet.

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Löschen Sie den Cluster und den Container

Wenn Sie Ihr Projekt behalten und nur die in dieser Anleitung verwendeten Ressourcen löschen möchten, dann löschen Sie den Cluster und das Image.

Zum Löschen eines Clusters mit dem gcloud-Befehlszeilentool führen Sie folgenden Befehl für den von Ihnen verwendeten Modus aus:

Standard

gcloud container clusters delete helloworld-gke  \
    --zone COMPUTE_ZONE

Autopilot

 gcloud container clusters delete helloworld-gke \
    --region COMPUTE_REGION

Mit dem folgenden Befehl löschen Sie ein Image in einem Ihrer Container Registry-Repositories:

gcloud container images delete gcr.io/PROJECT_ID/helloworld-gke

Weitere Informationen

Weitere Informationen zu Kubernetes finden Sie hier:

Weitere Informationen zur Bereitstellung in GKE finden Sie hier:

Weitere Informationen zum Erstellen, Entwickeln und Ausführen von Anwendungen in GKE direkt über Ihre IDE mit Cloud Code finden Sie hier: