Anwendung in einem Container-Image in einem GKE-Cluster bereitstellen

Diese Seite enthält Anleitungen für Folgendes:

Eine Hello-World-Anwendung erstellen.
Die Anwendung mit Cloud Build in einem Container-Image verpacken.
Einen Cluster in Google Kubernetes Engine (GKE) erstellen.
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.

Klicken Sie auf Anleitung, um eine detaillierte Anleitung für diese Aufgabe direkt im Cloud Shell-Editor zu erhalten:

Anleitung

Hinweis

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.

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

Zur Projektauswahl

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

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

Aktivieren Sie die APIs

Installieren Sie die Google Cloud CLI.

Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Hinweis: Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die neueste Version haben, indem Sie

gcloud components
      update

ausführen.

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

Zur Projektauswahl

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

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

Aktivieren Sie die APIs

Installieren Sie die Google Cloud CLI.

Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Hinweis: Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die neueste Version haben, indem Sie

gcloud components
      update

ausführen.

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

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
```
Erstellen Sie ein neues Modul namens example.com/helloworld:
```
go mod init example.com/helloworld
```

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 Artifact Registry hochgeladen werden.

Node.js

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und wechseln Sie dorthin:
```
mkdir helloworld-gke
cd helloworld-gke
```

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"
  }
}

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 Artifact Registry hochgeladen werden.

Python

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und wechseln Sie dorthin:
```
mkdir helloworld-gke
cd helloworld-gke
```

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.

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.

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

curl https://start.spring.io/starter.zip \
    -d dependencies=web \
    -d javaVersion=1.8 \
    -d type=maven-project \
    -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.

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 Artifact Registry hochgeladen werden.

C#

Installieren Sie das .NET SDK. Das .NET 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.
Erstellen Sie über Ihr Terminal ein neues, leeres Webprojekt:
```
dotnet new web -o helloworld-gke
```
Ändern Sie das Verzeichnis in helloworld-gke.
```
cd helloworld-gke
```

Aktualisieren Sie Program.cs, um Port 8080 zu überwachen:

var builder = WebApplication.CreateBuilder(args);

// Google Cloud Run sets the PORT environment variable to tell this
// process which port to listen to.
var port = Environment.GetEnvironmentVariable("PORT") ?? "8080";
var url = $"http://0.0.0.0:{port}";
var target = Environment.GetEnvironmentVariable("TARGET") ?? "World";

var app = builder.Build();

app.MapGet("/", () => $"Hello {target}!");

app.Run(url);

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

PHP

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-gke und wechseln Sie dorthin:
```
mkdir helloworld-gke
cd helloworld-gke
```
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 Artifact Registry hochgeladen werden.

Anwendung mit Cloud Build containerisieren

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:

Einfach loslegen (Go)

# Use the offical Go 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.22.0 as builder
WORKDIR /app

# Initialize a new Go module.
RUN go mod init quickstart-go

# Copy local code to the container image.
COPY *.go ./

# Build the command inside the container.
RUN CGO_ENABLED=0 GOOS=linux go build -o /quickstart-go

# 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 gcr.io/distroless/base-debian11

# Change the working directory.
WORKDIR /

# Copy the binary to the production image from the builder stage.
COPY --from=builder /quickstart-go /quickstart-go

# Run the web service on container startup.
USER nonroot:nonroot
ENTRYPOINT ["/quickstart-go"]

Node.js

# Use the official lightweight Node.js 16 image.
# https://hub.docker.com/_/node
FROM node:21-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 --omit=dev

# 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.12-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.
FROM mcr.microsoft.com/dotnet/sdk:6.0 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/aspnet:6.0
WORKDIR /app
COPY --from=build /app/out .

# Start the .dll (will have the same name as your .csproj file)
ENTRYPOINT ["dotnet", "helloworld-gke.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:8.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

Rufen Sie Ihre Google Cloud-Projekt-ID ab:
```
gcloud config get-value project
```
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 im selben Ort wie der Cluster zu erstellen:
```
gcloud artifacts repositories create hello-repo \
    --project=PROJECT_ID \
    --repository-format=docker \
    --location=us-central1 \
    --description="Docker repository"
```
Ersetzen Sie die folgenden Werte:
- PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
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 us-central1-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.

Erstellen Sie den Cluster.

gcloud container clusters create-auto helloworld-gke \
  --location us-central1

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.

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

Anwendung bereitstellen

Die Anwendung umfasst einen Frontend-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.

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-central1.

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"
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
            ephemeral-storage: "1Gi"
          limits:
            memory: "1Gi"
            cpu: "500m"
            ephemeral-storage: "1Gi"

Stellen Sie die Ressource im Cluster bereit:
```
kubectl apply -f deployment.yaml
```
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
helloworld-gke    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.
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.

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.
Erstellen Sie den Hello-World-Service:
```
kubectl apply -f service.yaml
```

Suchen Sie die externe IP-Adresse des Service:

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 Service 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

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

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.

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:

gcloud container clusters delete helloworld-gke \
    --location us-central1

Mit dem folgenden Befehl löschen Sie ein Image in Ihrem Artifact Registry-Repository:

gcloud artifacts docker images delete \
    us-central1-docker.pkg.dev/PROJECT_ID/hello-repo/helloworld-gke

Weitere Informationen

Weitere Informationen zu Kubernetes finden Sie hier:

Weitere Informationen zur Erstellung von Clustern.
Weitere Informationen zu Kubernetes
Lesen Sie die Referenzdokumentation zu kubectl.

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: