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 jedoch auch Sprachen verwenden, die hier nicht behandelt werden.

Vorbereitung

  1. Melden Sie sich in Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, registrieren Sie sich hier für ein neues Konto.

  2. Wählen Sie in der GCP Console auf der Projektauswahlseite ein GCP-Projekt aus oder erstellen Sie eins.

    Zur Projektauswahl

  3. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Platform-Projekt aktiviert ist. So bestätigen Sie die Abrechnung für Ihr Projekt.

  4. Aktivieren Sie die Cloud Build und Google Kubernetes Engineerforderlichen APIs.

    APIs aktivieren

  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 ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    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 ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie eine Datei mit dem Namen app.py und fügen Sie den folgenden Code in diese 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 HelloworldApplicationdurch 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 ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie eine Datei mit dem Namen index.php und fügen Sie den folgenden Code in diese 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 ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    mkdir helloworld-gke
    cd helloworld-gke
    
  2. Erstellen Sie eine Datei mit dem Namen app.rb und fügen Sie den folgenden Code in diese 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.2 image.
    # https://hub.docker.com/_/php
    FROM php:7.2-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 entspricht in etwa dem Ausführen von docker build und docker push, erfolgt aber in der Google Cloud. 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.

Kubernetes Engine-Cluster erstellen

Ein GKE-Cluster ist ein verwalteter Satz von Compute Engine-VMs, die als ein GKE-Cluster genutzt werden. In dieser Anleitung wird ein einzelner Knoten verwendet.

  1. Erstellen Sie den Cluster. Ersetzen Sie YOUR_GCP_ZONE durch die Google Cloud-Zone, in der Sie den Cluster hosten möchten. Eine vollständige Liste finden Sie unter Geografie und Regionen.

    gcloud container clusters create helloworld-gke \
       --num-nodes 1 \
       --enable-basic-auth \
       --issue-client-certificate \
       --zone YOUR_GCP_ZONE
    
  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 angegeben, ob Sie Zugriff darauf 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. Ein Service zum Festlegen des Zugriffs auf Ihre Anwendung.

App 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: extensions/v1beta1
    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 der Bereitstellung:

    kubectl get deployments
    

    Sobald es die gleiche Anzahl von AVAILABLE-Pods wie DESIRED-Pods hat, ist das Deployment abgeschlossen.

    NAME               DESIRED   CURRENT   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 Serviceadresse aufgerufen werden. In Ihrer Hello-World-Anwendung definiert der "Hello"-Service einen Load-Balancer, um über eine einzelne IP-Adresse auf die hello-app-Pods zuzugreifen. 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 Service Pods von verschiedenen Replikatsätzen verwenden. Gleichzeitig besteht mit Labels die Möglichkeit, dass mehrere Services einen einzelnen Pod nutzen.

  2. Erstellen Sie den Hello-World-Service:

    kubectl apply -f service.yaml
    
  3. Rufen Sie die externe IP-Adresse des Service ab:

    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!

# Example cURL call to your running appication on GKE
$ kubectl get service hello \
    -o=custom-columns=NAME:.status.loadBalancer.ingress[*].ip --no-headers
35.111.111.11
$ curl 35.111.111.11
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

Wenn Sie Ihr Google Cloud-Projekt löschen, wird die Abrechnung für alle in diesem Projekt verwendeten Ressourcen beendet.

  1. Rufen Sie in der GCP Console die Seite Ressourcen verwalten auf.

    Zur Seite "Ressourcen verwalten"

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen .
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf 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 den folgenden Befehl aus:

gcloud container clusters delete helloworld-gke

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 zur Bereitstellung in GKE direkt über Ihre IDE mit Cloud Code finden Sie hier:

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...

Dokumentation zu Kubernetes Engine