Anwendung in einem Container-Image in einem GKE-Cluster 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 ein Projekt aktiviert ist.

  4. Artifact Registry, Cloud Build, and Google Kubernetes Engine APIs aktivieren.

    Aktivieren Sie die APIs

  5. Installieren und initialisieren Sie Google Cloud CLI.

  6. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

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

  8. Artifact Registry, Cloud Build, and Google Kubernetes Engine APIs aktivieren.

    Aktivieren Sie die APIs

  9. Installieren und initialisieren Sie Google Cloud CLI.
  10. 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:

    quickstart/go/helloworld.go
    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 Artifact 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:

    quickstart/nodejs/package.json
    {
  "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:

    quickstart/nodejs/index.js
    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 Artifact 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:

    quickstart/python/app.py
    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.6.6 \
    -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.

    quickstart/java/src/main/java/com/example/helloworld/HelloworldApplication.java
    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 Artifact 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:

    quickstart/dotnet/Program.cs
    // 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 Artifact 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:

    quickstart/php/index.php
    <?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 Artifact 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:

    quickstart/ruby/app.rb
    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:

    quickstart/ruby/Gemfile
    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

    quickstart/go/Dockerfile
    # 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

    quickstart/nodejs/Dockerfile
    # Use the official lightweight Node.js 16 image.
# https://hub.docker.com/_/node
FROM node:17-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:

    quickstart/nodejs/.dockerignore
    Dockerfile
README.md
node_modules
npm-debug.log

    Python

    quickstart/python/Dockerfile
    # 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:

    quickstart/python/.dockerignore
    Dockerfile
README.md
*.pyc
*.pyo
*.pyd
__pycache__

    Java

    quickstart/java/Dockerfile
    # 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#

    quickstart/dotnet/Dockerfile
    # 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:

    quickstart/dotnet/.dockerignore
    Dockerfile
README.md
**/obj/
**/bin/

    PHP

    quickstart/php/Dockerfile
    # 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:

    quickstart/php/.dockerignore
    Dockerfile
README.md
vendor

    Ruby

    quickstart/ruby/Dockerfile
    # 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

  3. In dieser Kurzanleitung speichern Sie den Container in Artifact Registry und stellen ihn aus der Registry in Ihrem Cluster bereit. Führen Sie den folgenden Befehl aus, um ein Repository mit dem Namen hello-repo in derselben Region wie der Cluster zu erstellen:

    gcloud artifacts repositories create hello-repo \
    --project=PROJECT_ID \
    --repository-format=docker \
    --location=LOCATION \
    --description="Docker repository"

    Ersetzen Sie die folgenden Werte:

    • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.

    • LOCATION ist der Speicherort für das Repository, z. B. us-west1. Im nächsten Abschnitt erstellen Sie den Cluster für die Bereitstellung des Container-Images in derselben Region.

      Führen Sie den folgenden Befehl aus, um eine Liste der verfügbaren Standorte aufzurufen:

      gcloud artifacts locations list

  4. 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:

     gcloud builds submit \
    --tag LOCATION-docker.pkg.dev/PROJECT_ID/hello-repo/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 Autopilot-Modus verwenden, ist Ihr Cluster regional. Legen Sie daher die Standard-Computing-Region fest. Wenn Sie den Standardmodus verwenden, ist Ihr Cluster für diese Anleitung zonal. Legen Sie dann die Standard-Computing-Zone fest.

  1. Erstellen Sie den Cluster.

    Autopilot

    Ersetzen Sie COMPUTE_REGION durch die Google Cloud-Region, in der Sie den Cluster hosten möchten, z. B. us-west1. Wählen Sie dieselbe Region wie in Ihrem Artifact Registry-Repository aus.

     gcloud container clusters create-auto helloworld-gke \
    --region COMPUTE_REGION

    Standard

    Ersetzen Sie COMPUTE_ZONE durch die Google Cloud-Zone, in der Sie den Cluster hosten möchten, z. B. us-west1-a. Wählen Sie eine Zone in derselben Region wie für Ihr Artifact Registry-Repository aus.

    gcloud container clusters create helloworld-gke \
    --num-nodes 1 \
    --zone COMPUTE_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 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: Ersetzen Sie die folgenden Werte in Ihrer Datei:

    • $GCLOUD_PROJECT ist Ihre Google Cloud-Projekt-ID.
    • $LOCATION ist der Speicherort des Repositorys, z. B. us-west1.
    quickstart/deployment.yaml
    
# Copyright 2021 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.

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 $LOCATION with your Artifact Registry location (e.g., us-west1).
        # Replace $GCLOUD_PROJECT with your project ID.
        image: $LOCATION-docker.pkg.dev/$GCLOUD_PROJECT/hello-repo/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:

    quickstart/service.yaml
    
# Copyright 2021 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.

# 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 Anleitung 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 Artifact 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.

Führen Sie zum Löschen eines Clusters mit der Google Cloud CLI den 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 Ihrem Artifact Registry-Repository:

gcloud artifacts docker images delete \
    LOCATION-docker.pkg.dev/PROJECT_ID/hello-repo/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: