Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklung zur Produktion mit Cloud Run in drei einfachen Schritten

1. Einführung

Warum ist die Verwaltung von Anwendungen so schwierig?

Ein wichtiger Grund ist, dass Entwickler oft Teilzeit-Systemadministratoren sein müssen. Berücksichtigen Sie diese (teilweise) Liste von Problemen, um eine moderne Webanwendung für die Produktion zu entwickeln, bereitzustellen und zu verwalten :

Ich weiß nicht über dich, aber über das sind alles Dinge, über die ich mir keine Sorgen machen will! Was ich wirklich überdenken möchte, ist meine Anwendungslogik:

Das ist es in aller Munde – mit Cloud Run können Sie sich ganz auf Ihre Anwendung konzentrieren und die gesamte Verwaltung und Wartung einem anderen, nämlich Google, überlassen, der Millionen von Stunden in die Optimierung und Optimierung seiner Fähigkeiten in diesem Bereich investiert hat.

Zusätzlich zu den oben genannten administrativen Herausforderungen müssen Sie sich auch mit folgenden Aufgaben befassen:

Abhängigkeiten: Die Umgebung, in der Ihre App ausgeführt wird, sollte möglichst genau mit der Umgebung übereinstimmen, in der sie getestet wurde. Dabei kann es sich um verschiedene Dimensionen handeln, darunter Betriebssystem, Supportbibliotheken, Sprachinterpreter oder Compiler, Hardwarekonfiguration und viele andere Faktoren.
Verbreitung – Der Wechsel von einer lokalen Version einer App zu einer breiten Plattform, die im Internet verbreitet wird, erfordert häufig eine Änderung der Laufzeitumgebung, einen Quantensprung in der Komplexität und eine steile Lernkurve.

Cloud Run übernimmt diese und viele weitere Aufgaben für Sie. Aber ohne mein Wort zu glauben: Lassen Sie uns gemeinsam eine App erstellen und sehen, wie einfach der Wechsel von einer lokalen Entwicklungsumgebung zu einer produktionstauglichen Cloud-App in nur wenigen einfachen Schritten ist.

Aufgaben

Sie erstellen eine einfache Webanwendung und prüfen, ob sie in Ihrer Entwicklungsumgebung wie erwartet ausgeführt wird.
Dann wechseln Sie zu einer containerisierten Version derselben Anwendung. Dabei erfahren Sie, was Containerisierung bedeutet und warum sie so nützlich ist.
Schließlich stellen Sie Ihre Anwendung in der Cloud bereit und sehen, wie einfach sich der Cloud Run-Dienst über die Befehlszeile und die Google Cloud Console verwalten lässt.

Lerninhalte

Einfache Webserveranwendung in Python erstellen
Anwendung in einem Docker-Container verpacken, der überall ausgeführt werden kann
Anwendung in der Cloud bereitstellen, damit jeder Ihre neue Kreation ausprobieren kann
Wie Sie die obigen Schritte mithilfe von Buildpacks noch weiter vereinfachen können
Google Cloud-Befehlszeilentool und die Web-UI der Cloud Console verwenden

Du brauchst...

Einen Webbrowser
Ein Google-Konto

Dieses Lab richtet sich an Entwickler aller Stufen, auch Anfänger. Obwohl Sie Python verwenden, müssen Sie nicht mit der Python-Programmierung vertraut sein, um zu verstehen, wo das Problem liegt. Wir erklären Ihnen nämlich den gesamten verwendeten Code.

2. Jetzt einrichten

In diesem Abschnitt werden alle Schritte behandelt, die für den Einstieg in dieses Lab erforderlich sind.

Umgebung für das selbstbestimmte Lernen einrichten

Melden Sie sich in der Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Notieren Sie sich die Projekt-ID, also den projektübergreifend nur einmal vorkommenden Namen eines Google Cloud-Projekts. Der oben angegebene Name ist bereits vergeben und kann leider nicht mehr verwendet werden. Sie wird in diesem Codelab später als PROJECT_ID bezeichnet.

Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Google Cloud-Ressourcen nutzen zu können.

Dieses Codelab sollte ohne großen Aufwand betrieben werden. Folgen Sie der Anleitung im Abschnitt „Bereinigen“, . Hier erfahren Sie, wie Sie Ressourcen herunterfahren, damit Ihnen über dieses Tutorial hinaus keine Kosten entstehen. Neue Google Cloud-Nutzer haben Anspruch auf eine kostenlose Testversion von 300$.

Cloud Shell starten

In diesem Lab arbeiten Sie in einer Cloud Shell-Sitzung, einem Befehlsinterpreter, der von einer virtuellen Maschine in der Cloud von Google gehostet wird. Sie können diesen Abschnitt genauso einfach lokal auf Ihrem Computer ausführen, aber mit Cloud Shell erhalten alle Zugriff auf eine reproduzierbare Version in einer einheitlichen Umgebung. Sie können diesen Abschnitt nach dem Lab gerne auf Ihrem eigenen Computer wiederholen.

Cloud Shell aktivieren

Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie Cloud Shell noch nie gestartet haben, wird ein Zwischenbildschirm (below the fold) angezeigt, in dem beschrieben wird, worum es sich dabei handelt. Klicken Sie in diesem Fall auf Weiter. Der Chat wird nie wieder angezeigt. So sieht dieser einmalige Bildschirm aus:

Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.

Diese virtuelle Maschine verfügt über alle Entwicklungstools, die Sie benötigen. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können Sie ganz einfach mit einem Browser oder Ihrem Chromebook erledigen.

Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie bereits authentifiziert sind und dass das Projekt bereits auf Ihre Projekt-ID eingestellt ist.

Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob der gcloud-Befehl Ihr Projekt kennt:

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

Legen Sie in Ihrem Terminal einige Umgebungsvariablen fest, die die Arbeit in den nachfolgenden Schritten erleichtern:

export PROJ=$GOOGLE_CLOUD_PROJECT 
export APP=hello 
export PORT=8080
export REGION="us-central1"
export TAG="gcr.io/$PROJ/$APP"

APIs aktivieren

In späteren Schritten sehen Sie, wo diese Dienste benötigt werden (und warum). Führen Sie vorerst den folgenden Befehl aus, um Ihrem Projekt Zugriff auf die Cloud Build-, Container Registry- und Cloud Run-Dienste zu gewähren:

gcloud services enable cloudbuild.googleapis.com         \
                       containerregistry.googleapis.com  \
                       run.googleapis.com

Wenn die Aktivierung erfolgreich war, erhalten Sie eine Meldung, die ungefähr so aussieht:

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

3. Einfache Webanwendung erstellen

Klicken Sie zuerst oben im Cloud Shell-Bereich auf die Schaltfläche Open Editor. Sie sieht so aus:

Sie befinden sich dann in einer IDE-Umgebung ähnlich wie Visual Studio Code, in der Sie unter anderem Projekte erstellen, Quellcode bearbeiten und Ihre Programme ausführen können. Wenn der Bildschirm zu eng ist, können Sie die Trennlinie zwischen der Konsole und dem Bearbeitungs-/Terminalfenster erweitern oder verkleinern, indem Sie die horizontale Leiste zwischen diesen beiden Regionen ziehen, die hier hervorgehoben sind:

Mit den Schaltflächen Open Editor und Open Terminal können Sie zwischen Editor und Terminal wechseln. Versuchen Sie jetzt, zwischen diesen beiden Umgebungen zu wechseln.

Erstellen Sie als Nächstes einen Ordner, in dem Ihre Arbeit für dieses Lab gespeichert werden soll. Wählen Sie dazu „Datei“ -> „Neuer Ordner“ aus, geben Sie hello ein und klicken Sie auf OK. Alle Dateien, die Sie in diesem Lab erstellen, und Ihre Arbeit in Cloud Shell finden Sie in diesem Ordner.

Erstellen Sie jetzt eine requirements.txt-Datei. Dadurch weiß Python, von welchen Bibliotheken Ihre Anwendung abhängt. Für diese einfache Webanwendung verwenden Sie ein beliebtes Python-Modul zum Erstellen von Webservern namens Flask und ein Webserver-Framework namens gunicorn. Klicken Sie im Cloud Editor-Fenster auf das Menü „Datei“ -> „Neue Datei“, um eine neue Datei zu erstellen. Wenn Sie nach dem Namen der neuen Datei gefragt werden, geben Sie requirements.txt ein und drücken Sie die Schaltfläche OK. Achten Sie darauf, dass sich die neue Datei im Projektordner hello befindet.

Geben Sie die folgenden Zeilen in die neue Datei ein, um anzugeben, dass Ihre Anwendung vom Python-Paket Flask und dem Gunicorn-Webserver abhängt.

Flask
gunicorn

Sie müssen diese Datei nicht explizit speichern, da der Cloud-Editor Änderungen automatisch für Sie speichert.

Version 1: Hallo Welt!

Erstellen Sie mit derselben Technik eine weitere neue Datei mit dem Namen main.py. Dies wird die Hauptdatei (und einzige) Python-Quelldatei Ihrer Anwendung sein. Achten Sie auch hier darauf, dass sich die neue Datei im Projektordner hello befindet.

Fügen Sie den folgenden Code in diese Datei ein:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from the environment.

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
    html = "<h1>Hello world!</h1>"
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Wechseln Sie zurück zum Terminal und wechseln Sie mit dem folgenden Befehl in den Projektordner:

cd hello

Führen Sie den folgenden Befehl aus, um die Projektabhängigkeiten zu installieren:

pip3 install -r requirements.txt

Starten Sie nun Ihre App, indem Sie diesen Befehl im Terminal ausführen:

python3 main.py

Zu diesem Zeitpunkt wird Ihre Anwendung auf der virtuellen Maschine ausgeführt, die für Ihre Cloud Shell-Sitzung vorgesehen ist. Cloud Shell umfasst einen Proxy-Mechanismus, mit dem Sie von überall im globalen Internet auf Webserver (wie den von Ihnen gerade gestarteten) auf Ihrer virtuellen Maschine zugreifen können.

Klicken Sie auf die Schaltfläche web preview und dann auf den Menüpunkt Preview on Port 8080:

Daraufhin wird ein Webbrowser-Tab für Ihre laufende Anwendung geöffnet, der ungefähr so aussehen sollte:

Version 2: URL-Pfad übernehmen

Kehren Sie über die Schaltfläche Open Editor zum Cloud Editor zurück und fügen Sie Unterstützung für das Echo eines optionalen URL-Suffix hinzu. Aktualisieren Sie dazu Ihre main.py-Datei so:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])     # ← NEW
def say_hello(name="world"):               # ← MODIFIED
    html = f"<h1>Hello {name}!</h1>"       # ← MODIFIED
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Wechseln Sie über die Schaltfläche Open Terminal zurück zum Terminal und geben Sie control-C ein (Strg-Taste gedrückt halten und „C“ drücken), um die ausgeführte App zu beenden und neu zu starten. Geben Sie dazu Folgendes ein:

python3 main.py

Klicken Sie noch einmal auf die Schaltfläche „web preview“ und dann auf den Menüpunkt Preview on Port 8080, um einen Browsertab für die laufende App zu öffnen. Jetzt sollten Sie die Nachricht "Hello world!" Ersetzen Sie jetzt den URL-Text nach dem Schrägstrich durch einen beliebigen String Ihrer Wahl (z. B. /your-name). Prüfen Sie, ob Folgendes angezeigt wird:

Version 3: Zufällige Farben

Wenn Sie jetzt Unterstützung für zufällige Hintergrundfarben hinzufügen möchten, kehren Sie über die Schaltfläche Open Editor zum Cloud Editor zurück und aktualisieren Sie Ihre main.py-Datei so:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from the environment.

# This function decides whether foreground text should be
# displayed in black or white, to maximize fg/bg contrast.
def set_text_color(rgb):                      # ← NEW
    sum = round(                              # ← NEW
        (int(rgb[0]) * 0.299)                 # ← NEW
        + (int(rgb[1]) * 0.587)               # ← NEW
        + (int(rgb[2]) * 0.114)               # ← NEW
    )                                         # ← NEW
    return "black" if sum > 186 else "white"  # ← NEW


# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
# To verify each new invocation of these requests, the HTML document
# includes CSS styling to produce a randomly colored background.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])
def say_hello(name="world"):
    bg = random.sample(range(1, 255), 3)                       # ← NEW
    hex = (int(bg[0]) * 256) + (int(bg[1]) * 16) + int(bg[2])  # ← NEW
    fg_color = set_text_color(bg)                              # ← NEW
    bg_color = f"#{hex:06x}"                                   # ← NEW
    style = f"color:{fg_color}; background-color:{bg_color}"   # ← NEW
    html = f'<h1 style="{style}">Hello {name}!</h1>'           # ← MODIFIED
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

python3 main.py

Klicken Sie noch einmal auf die Schaltfläche „web preview“ und dann auf den Menüpunkt Preview on Port 8080, um einen Browsertab für die laufende App zu öffnen. Sie sollten den generierten Text mit einem beliebigen Suffix oder dem Standardtext „Hello world!“ sehen. vor einem willkürlichen Hintergrund angezeigt. Beispiel:

Laden Sie die Seite mehrmals neu, um zu sehen, dass sich die zufällige Hintergrundfarbe bei jedem Aufruf der App ändert.

Damit ist Ihre App fertig. Glückwunsch! Im nächsten Schritt erfahren Sie, wie Sie Ihre Anwendung in einem Container verpacken und warum dies sinnvoll ist.

4. Anwendung containerisieren

Was ist ein Container?

Mit Containern im Allgemeinen und Docker im Besonderen können wir eine modulare Box erstellen, in der eine Anwendung mit allen zugehörigen Abhängigkeiten gebündelt ausgeführt wird. Das Ergebnis wird als Container-Image bezeichnet. In diesem Abschnitt erstellen Sie ein Container-Image, mit dem Sie Ihre Anwendung und alle zugehörigen Abhängigkeiten kapseln.

In einem vorherigen Schritt mussten Sie pip3 install -r requirements.txt ausführen, als Sie Ihre App in einer Entwicklungsumgebung ausgeführt haben. Dabei mussten Sie darauf achten, dass die Datei „requirements.txt“ alle abhängigen Bibliotheken und entsprechenden Versionen enthielt. Bei Containern werden diese Anforderungen zusammen mit dem Container-Image installiert. Der Nutzer des Containers muss sich also nicht um die Installation kümmern.

Dieses Container-Image bildet den grundlegenden Baustein für die Bereitstellung Ihrer Anwendung in Cloud Run. Da Container auf fast jedem virtuellen oder echten Server verwendet werden können, haben wir die Möglichkeit, Ihre Anwendung an jedem beliebigen Ort bereitzustellen und von einem Dienstanbieter zu einem anderen oder von einem lokalen System in die Cloud zu verschieben.

Mit Containern können Sie:

Reproduzierbar – Container sind eigenständig und vollständig
tragbar – Container sind branchenübergreifende Bausteine, die die Übertragbarkeit von Anwendungen über Cloud-Anbieter und Umgebungen hinweg ermöglichen

Kurz gesagt bieten Container die Möglichkeit, einmal zu schreiben und überall auszuführen. Eine Ausnahme von dieser Regel besteht darin, dass der generierte Container nur auf dem Prozessortyp ausgeführt werden kann, auf dem Sie ihn erstellt haben. Es gibt aber auch Möglichkeiten, Containerversionen für andere Hardwarekonfigurationen zu generieren.

Genug geredet – lass uns einen Container erstellen! Sie verwenden eine bestimmte Technologie zum Erstellen eines Containers namens Docker.

Erstellen Sie im Cloud-Editor eine neue Datei mit dem Namen Dockerfile. Diese Datei ist eine Vorlage für die Erstellung Ihres Bildes. Darin wird Docker über Ihre Betriebsumgebung und Ihren Quellcode informiert. Außerdem erfahren Sie, wie Sie die Abhängigkeiten installieren, Ihre App erstellen und Ihren Code ausführen.

# Use an official lightweight Python image.
FROM python:3.9-slim

# Copy local code to the container image.
WORKDIR /app
COPY main.py .
COPY requirements.txt .

# Install dependencies into this container so there's no need to 
# install anything at container run time.
RUN pip install -r requirements.txt

# Service must listen to $PORT environment variable.
# This default value facilitates local development.
ENV PORT 8080

# Run the web service on container startup. Here you use the gunicorn
# server, with one worker process and 8 threads. For environments 
# with multiple CPU cores, increase the number of workers to match 
# the number of cores available.
CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 main:app

Erstellen Sie im Cloud-Terminal Ihr Container-Image mit Cloud Build, indem Sie den folgenden Befehl ausführen:

gcloud builds submit --tag $TAG

Nach der Übertragung in die Registry wird die Meldung SUCCESS mit dem Image-Namen angezeigt. Dieser sollte in etwa so aussehen: gcr.io/<project-id>/hello. Das Image wird jetzt in Google Container Registry gespeichert und kann jederzeit und überall wiederverwendet werden.

Mit dem folgenden Befehl können Sie alle Container-Images auflisten, die mit Ihrem aktuellen Projekt verknüpft sind:

gcloud container images list

Führen Sie jetzt die Anwendung mit den folgenden docker-Befehlen lokal in Cloud Shell aus und testen Sie sie:

docker run -p $PORT:$PORT -e PORT=$PORT $TAG

Die Option -p $PORT:$PORT weist Docker an, den externen Port $PORT (oben auf 8080 festgelegt) in der Hostumgebung der gleichen Portnummer im ausgeführten Container zuzuordnen. Dies erleichtert das Leben, da der von Ihnen geschriebene Servercode und die externe Portnummer, mit der Sie sich beim Testen Ihrer Anwendung verbinden, identisch sind (8080). Sie können aber auch einfach die Option „-p“ verwenden, um beliebige externe Ports auf dem Host einem gewünschten internen Port im Container zuzuordnen.

Die Option -e PORT=$PORT weist Docker an, die Umgebungsvariable $PORT (oben auf 8080 festgelegt) für Ihre Anwendung verfügbar zu machen, die im Container ausgeführt wird.

Jetzt können Sie Ihre Anwendung testen, indem Sie einen Webbrowser auf den Python-Code verweisen, der im Container ausgeführt wird. Klicken Sie im Cloud Shell-Fenster auf „Webvorschau“. und wählen Sie wie im vorherigen Schritt "Vorschau auf Port 8080" aus.

Das Ergebnis sollte Ihnen bekannt vorkommen: Sie sollten den generierten Text vor einem zufällig farbigen Hintergrund sehen, so wie Sie es getan haben, als Sie die App direkt in Ihrem Cloud Shell-Terminal ausgeführt haben. Laden Sie die Seite mehrmals neu, um zu sehen, dass sich die zufällige Hintergrundfarbe bei jedem Aufruf der App ändert.

Glückwunsch! Sie haben jetzt eine Containerversion Ihrer Anwendung ausgeführt. Im nächsten Abschnitt wandeln Sie Ihr Container-Image in eine Webanwendung in Produktionsqualität um, ohne eine Codezeile zu berühren.

5. In die Cloud...

Nachdem Sie Ihre Anwendung containerisiert haben, können Sie sie nun in der Cloud bereitstellen. Aber Sie möchten mehr tun, als es nur zu teilen. Achten Sie dabei auf Folgendes:

läuft zuverlässig – Sie erhalten automatische Fehlertoleranz, falls ein Computer, auf dem Ihre App ausgeführt wird, abstürzt.
wird automatisch skaliert – deine App kann mit hohem Traffic-Aufkommen Schritt halten und ihre Kapazität bei Nichtnutzung automatisch reduzieren.
Ihre Kosten werden minimiert, da Ihnen keine Ressourcen in Rechnung gestellt werden, die Sie nicht verwenden. Ihnen werden nur die Kosten in Rechnung gestellt, die während der Reaktion auf Traffic verbraucht wurden.
ist über einen benutzerdefinierten Domainnamen zugänglich – Sie haben Zugriff auf eine Ein-Klick-Lösung, mit der Sie Ihrem Dienst einen benutzerdefinierten Domainnamen zuweisen können.
bietet eine hervorragende Reaktionszeit – Kaltstarts reagieren relativ schnell, aber Sie können dies durch Festlegen einer Mindestinstanzkonfiguration optimieren.
unterstützt Ende-zu-Ende-Verschlüsselung mit der standardmäßigen SSL/TLS-Websicherheit. Wenn Sie einen Dienst bereitstellen, erhalten Sie kostenlos und automatisch die Standard-Webverschlüsselung sowie die entsprechenden erforderlichen Zertifikate.

Wenn Sie Ihre Anwendung in Google Cloud Run bereitstellen, erhalten Sie alle oben genannten und weitere Funktionen.

Anwendung in Cloud Run bereitstellen

Ändern Sie zuerst Ihre App, damit Sie die neue Version von der alten unterscheiden können. Ändern Sie dazu die Datei main.py so, dass die Standardnachricht von „Hello world!“ in „Hello from Cloud Run!“. Mit anderen Worten, ändern Sie diese Zeile in main.py folgendermaßen:

def say_hello(name="world"):

in:

def say_hello(name="from Cloud Run"):

Cloud Run ist regional. Das bedeutet, dass sich die Infrastruktur, in der Ihre Cloud Run-Dienste ausgeführt werden, in einer bestimmten Region befindet und von Google verwaltet wird, damit sie in allen Zonen innerhalb dieser Region redundant verfügbar ist. Klicken Sie im Menü oben über die Umgebungsvariable REGION eine Standardregion definiert.

Erstellen Sie mit dem folgenden Befehl das Container-Image neu und stellen Sie die Containeranwendung in Cloud Run bereit:

gcloud builds submit --tag $TAG
gcloud run deploy "$APP"   \
  --image "$TAG"           \
  --platform "managed"     \
  --region "$REGION"       \
  --allow-unauthenticated

Sie können auch mit gcloud config set run/region $REGION eine Standardregion definieren.
Mit der Option --allow-unauthenticated wird der Dienst öffentlich verfügbar. Um nicht authentifizierte Anfragen zu vermeiden, verwenden Sie stattdessen --no-allow-unauthenticated.

Das hier angegebene Image ist das Docker-Image, das Sie im letzten Schritt erstellt haben. Dank des Cloud Build-Dienstes, der das resultierende Image in Google Container Registry gespeichert hat, kann der Cloud Run-Dienst es finden und für Sie bereitstellen.

Warten Sie dann einige Sekunden, bis die Bereitstellung abgeschlossen ist. Wenn die Bereitstellung erfolgreich war, wird in der Befehlszeile die Dienst-URL angezeigt:

Deploying container to Cloud Run service [hello] in project [PROJECT_ID...
✓ Deploying new service... Done.                                   
  ✓ Creating Revision... Revision deployment finished. Waiting for health check...
  ✓ Routing traffic...
  ✓ Setting IAM Policy...
Done.
Service [hello] revision [hello-...] has been deployed and is serving 100 percent of traffic.
Service URL: https://hello-....a.run.app

Sie können die Dienst-URL auch mit diesem Befehl abrufen:

gcloud run services describe hello  \
  --platform managed                \
  --region $REGION                  \
  --format "value(status.url)"

Die Anzeige sollte in etwa so aussehen:

https://hello-....a.run.app

Dieser Link ist eine dedizierte URL mit TLS-Sicherheit für Ihren Cloud Run-Dienst. Dieser Link ist dauerhaft (solange Sie Ihren Dienst nicht deaktivieren) und irgendwo im Internet verwendbar ist. Dabei wird nicht der zuvor erwähnte Proxymechanismus von Cloud Shell verwendet, der von einer vorübergehenden virtuellen Maschine abhängt.

Klicken Sie auf das hervorgehobene Symbol Service URL, um die laufende App in einem Webbrowser-Tab zu öffnen. Das Ergebnis sollte die Nachricht „Hello from Cloud Run!“ enthalten. eine Nachricht vor einem willkürlichen Hintergrund.

Glückwunsch! Ihre Anwendung wird jetzt in der Cloud von Google ausgeführt. Sie müssen sich keine Gedanken mehr darüber machen, dass Ihre App öffentlich verfügbar ist, mit TLS-Verschlüsselung (HTTPS) und der automatischen Skalierung auf schwindelerregende Traffic-Ebenen.

Aber ich denke, dieser Prozess könnte noch einfacher sein...

6. Container automatisch erstellen

Das ist alles ziemlich cool, aber was ist, wenn ich nicht einmal über Dockerfiles und Container nachdenken möchte? Was wäre, wenn ich mich wie die meisten Entwickler nur auf das Schreiben meines Anwendungscodes konzentrieren und jemand anderen die Containerisierung überlassen möchte. Nun, Sie haben Glück, weil Cloud Run den Open-Source-Standard Buildpacks unterstützt, der aus genau diesem Grund besteht: um den Prozess der Containererstellung aus einer Sammlung von Quelldateien zu automatisieren.

Es gibt einige Fälle, in denen ein Entwickler lieber ein explizites Dockerfile verwenden möchte, z. B. wenn er beim Erstellen seines Containers ein hohes Maß an Anpassung wünschen. In gängigen Fällen wie dieser Übung funktionieren Buildpacks jedoch gut und vermeiden die Notwendigkeit, Dockerfile manuell zu erstellen. Ändern wir nun Ihren Code zur Verwendung von Buildpacks.

Ändern Sie zuerst Ihre App, damit Sie die neue Version von der alten unterscheiden können. Ändern Sie dazu die Datei main.py so, dass sich die Standardnachricht von „Hello from Cloud Run!“ ändert. in „Hello from Cloud Run with Buildpacks!“. Mit anderen Worten, ändern Sie diese Zeile in main.py folgendermaßen:

def say_hello(name="from Cloud Run"):

in:

def say_hello(name="from Cloud Run with Buildpacks"):

Jetzt nutzen wir Buildpacks, indem wir eine neue Datei mit dem Namen Procfile erstellen. Erstellen Sie nun diese Datei im Cloud-Editor und fügen Sie diese Textzeile ein:

web: python3 main.py

Dadurch wird dem Buildback-System mitgeteilt, wie Ihre App im automatisch generierten Container ausgeführt werden soll. So benötigen Sie nicht einmal ein Dockerfile mehr. Um dies zu überprüfen, löschen Sie das Dockerfile und führen den folgenden Befehl im Cloud Shell-Terminal aus:

gcloud beta run deploy "$APP"  \
    --source .                 \
    --platform "managed"       \
    --region "$REGION"         \
    --allow-unauthenticated

Dieser ähnelt dem Befehl, den Sie im letzten Schritt zum Bereitstellen Ihrer App ausgeführt haben. Dieses Mal haben Sie jedoch die Option --image durch die Option --source . ersetzt. Dadurch wird dem Befehl gcloud mitgeteilt, dass er Buildpacks verwenden soll, um das Container-Image anhand der Quelldateien zu erstellen, die er im aktuellen Verzeichnis findet. dot in --source . ist die Abkürzung für das aktuelle Verzeichnis. Da der Dienst das Container-Image implizit verwaltet, müssen Sie bei diesem gcloud-Befehl kein Image angeben.

Prüfen Sie noch einmal, ob die Bereitstellung funktioniert hat. Klicken Sie dazu auf das hervorgehobene Service URL, um einen Webbrowser-Tab für die ausgeführte Anwendung zu öffnen, und prüfen Sie, ob in Ihrem Dienst „Hello from Cloud Run with Buildpacks“ angezeigt wird. vor einem willkürlichen Hintergrund.

Beachten Sie, dass Sie durch die Verwendung von Buildpacks zur Herstellung von Dockerfile die drei einfachen Schritte auf zwei reduziert haben:

Erstellen Sie eine Anwendung in Ihrer Entwicklungsumgebung.
Stellen Sie mit einem einzigen Befehl genau denselben Code in der Cloud bereit.

7. Muss ich die Befehlszeile verwenden?

Nein! Wie bei fast jedem Google Cloud-Dienst gibt es drei Möglichkeiten, mit Cloud Run zu interagieren:

Das gcloud-Befehlszeilentool, das Sie gerade kennengelernt haben.
Eine umfangreiche Weboberfläche, die über die Cloud Console eine intuitive Interaktionsmöglichkeit mit Punkt- und Klickinteraktionen unterstützt.
Programmatisch mithilfe von Google-Clientbibliotheken, die für viele gängige Sprachen verfügbar sind, darunter Java, C#, Python, Go, JavaScript, Ruby, C/C++ und andere.

Stellen Sie nun über die Console-UI eine zusätzliche Instanz Ihrer Cloud Run-Anwendung bereit. Rufen Sie über das Menü oben links die Landingpage des Cloud Run-Dienstes auf:

Sie sollten dann eine Zusammenfassung Ihrer Cloud Run-Dienste sehen, die in etwa so aussieht:

Klicken Sie auf „Dienst erstellen“. Link zum Starten des Bereitstellungsprozesses:

Geben Sie „Hallo wieder“ ein als Dienstnamen ein, übernehmen Sie die Standardbereitstellungsplattform und -region und klicken Sie auf "Weiter".

Geben Sie die folgende URL für das Container-Image ein: gcr.io/cloudrun/hello. Dieser Container wird von Google zu Testzwecken erstellt. Klicken Sie dann auf „Erweiterte Einstellungen“. Drop-down-Menü ein, um einige der vielen verfügbaren Konfigurationseinstellungen anzuzeigen. Hier einige Beispiele, die Sie anpassen können:

Portnummer und Containereinstiegspunkt (durch den der beim Erstellen des Containers angegebene Einstiegspunkt überschrieben wird)
Hardware: Arbeitsspeicher und Anzahl der CPUs
Skalierung: minimale und maximale Anzahl von Instanzen
Umgebungsvariablen
Sonstige: Einstellung für das Zeitlimit für Anfragen, maximale Anzahl von Anfragen pro Container, HTTP/2

Klicken Sie auf „Weiter“. um zum Dialogfeld zu gelangen. Im nächsten Dialogfeld können Sie angeben, wie der Dienst ausgelöst wird. Wählen Sie unter „Eingehender Traffic“ die Option „Gesamten Traffic zulassen“ und für „Authentifizierung“ die Option „Nicht authentifizierten Traffic zulassen“ aus.

Dies sind die liberalsten Einstellungen, da sie es jedem ermöglichen, von überall aus über das öffentliche Internet auf Ihre Cloud Run-Anwendung zuzugreifen, ohne Anmeldedaten zur Authentifizierung anzugeben. Möglicherweise möchten Sie für Ihre App restriktivere Einstellungen festlegen. Halten wir es für diese Lernübung aber einfach.

Klicken Sie jetzt auf die Schaltfläche Create, um den Cloud Run-Dienst zu erstellen. Nach einigen Sekunden sollte der neue Dienst in der Übersichtsliste der Cloud Run-Dienste angezeigt werden. Die Zusammenfassungszeile enthält die letzte Bereitstellung (Datum/Uhrzeit und von wem) sowie einige wichtige Konfigurationseinstellungen. Klicken Sie auf den Link für den Dienstnamen, um Details zu Ihrem neuen Dienst aufzurufen.

Um Ihren Service zu bestätigen, klicken Sie wie im folgenden Beispiel hervorgehoben auf die URL, die oben auf der Übersichtsseite angezeigt wird:

Auf dem Bildschirm sollte Folgendes zu sehen sein:

Nachdem Sie nun einen neuen Cloud Run-Dienst bereitgestellt haben, wählen Sie den Tab REVISIONS aus, um einige Möglichkeiten zum Verwalten mehrerer Bereitstellungen zu sehen.

Wenn Sie neue Versionen direkt über die Console bereitstellen möchten, klicken Sie auf die Schaltfläche EDIT & DEPLOY NEW REVISION (siehe Screenshot unten):

Klicken Sie jetzt auf diese Schaltfläche, um eine neue Version zu erstellen. Klicken Sie in der Nähe der Container-URL auf die Schaltfläche SELECT:

Suchen Sie im angezeigten Dialogfeld nach der einfachen Webanwendung, die Sie zuvor mit Buildpacks aus Cloud Build bereitgestellt haben, und klicken Sie dann auf „Auswählen“. Wählen Sie das Container-Image unter der

gcr.io/<project>/cloud-run-source-deploy

folder erstellen:

Wenn Sie eine Auswahl getroffen haben, scrollen Sie nach unten und klicken Sie auf die Schaltfläche DEPLOY. Sie haben jetzt eine neue Version Ihrer Anwendung bereitgestellt. Rufen Sie zur Bestätigung die Dienst-URL noch einmal auf und prüfen Sie, ob jetzt die bunte Nachricht „Hello from Cloud Run with Buildpacks“ angezeigt wird. Web-App.

Wie Sie sehen, enthält der Tab „Revisionen“ eine Zusammenfassung aller von Ihnen bereitgestellten Versionen und Sie sollten jetzt zwei Versionen für diesen Dienst sehen. Sie können eine bestimmte Überarbeitung auswählen, indem Sie auf das Optionsfeld links neben dem Überarbeitungsnamen klicken. Daraufhin wird eine Zusammenfassung der Überarbeitungsdetails auf der rechten Seite des Bildschirms angezeigt. Durch das Auswählen dieser Schaltflächen können Sie sehen, dass Ihre beiden Überarbeitungen von zwei verschiedenen Container-Images abgeleitet werden.

Mit der Schaltfläche MANAGE TRAFFIC können Sie die Verteilung der eingehenden Anfragen ändern, die an eine bestimmte Version gesendet wurden. Diese Möglichkeit, die Menge des Traffics, der an eine bestimmte Überarbeitung gesendet wird, zu optimieren, ermöglicht mehrere wertvolle Anwendungsfälle:

Canary-Test einer neuen Version Ihrer Anwendung mit einem kleinen Teil des eingehenden Traffics
Traffic von einem problematischen Release auf eine frühere Version wiederherstellen
A/B-Tests

Die MANAGE TRAFFIC-Schaltfläche finden Sie hier:

Konfigurieren Sie eine 50/50-Traffic-Aufteilung zwischen Ihren beiden Versionen, indem Sie eine 50/50-Traffic-Aufteilung wie folgt festlegen:

Klicken Sie nun auf die Schaltfläche SPEICHERN und prüfen Sie die 50/50-Aufteilung, indem Sie die URL des Dienstes wiederholt aufrufen. Im Durchschnitt wird die Hälfte Ihrer Anfragen von der aktuellen Version („Hello from Cloud Run with Buildpacks!“) und die andere Hälfte von der vorherigen Version („It's running!“) verarbeitet.

Über andere Tabs auf der Seite „Servicedetails“ können Sie die Leistung, den Traffic und die Logs überwachen, um wertvolle Informationen darüber zu erhalten, wie hart und wie gut Ihr Dienst funktioniert. Sie können den Zugriff auf Ihren Dienst auch über die „Berechtigungen“ . Nehmen Sie sich einen Moment Zeit und sehen Sie sich die Tabs auf dieser Seite an, um sich ein Bild von den verfügbaren Funktionen zu machen.

Programmatische Schnittstelle

Wie bereits erwähnt, können Sie Ihre Cloud Run-Dienste auch programmatisch erstellen, bereitstellen und verwalten. Bei manuellen Aufgaben ist diese Option komplexer als die Befehlszeile oder Webkonsole, ist aber definitiv die richtige Wahl für die Automatisierung von Cloud Run-Diensten. Sie haben die Möglichkeit, Google-Clientbibliotheken in verschiedenen gängigen Programmiersprachen zu verwenden.

8. App testen

In diesem letzten Schritt führen Sie einen künstlichen Belastungstest durch, um Ihre App einem Belastungstest zu unterziehen, und beobachten, wie sie mit der eingehenden Nachfrage skaliert. Sie verwenden ein Tool namens hey, das in Cloud Shell vorinstalliert ist und mit dem wir Lasttests ausführen und die Ergebnisse präsentieren können.

Test ausführen

Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus, um einen Lasttest durchzuführen:

hey -q 1000 -c 200 -z 30s https://hello-...run.app

Die Befehlsargumente werden so interpretiert:

-q 1000 – versuchen,die Last mit etwa 1.000 Anfragen pro Sekunde zu steigern
-c 200 – 200 parallele Worker zuweisen
-z 30s: Lassen Sie den Lasttest 30 Sekunden lang laufen.
Achten Sie darauf, Ihre Dienst-URL als letztes Argument in dieser Befehlszeile zu verwenden.

Die Ergebnisse Ihres Tests sollten in etwa so aussehen:

 Summary:
 Total:        30.2767 secs
 Slowest:      3.3633 secs
 Fastest:      0.1071 secs
 Average:      0.1828 secs
 Requests/sec: 1087.2387
 Total data:   3028456 bytes
 Size/request: 92 bytes

Response time histogram:
 0.107 [1]     |
 0.433 [31346] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
 0.758 [1472]  |■■
 1.084 [82]    |
 1.410 [4]     |
...

Latency distribution:
...
 50% in 0.1528 secs
 75% in 0.1949 secs
 90% in 0.2442 secs
 95% in 0.4052 secs
 99% in 0.7062 secs

Details (average, fastest, slowest):
...
 req write:    0.0000 secs, 0.0000 secs, 0.0232 secs
 resp wait:    0.1824 secs, 0.1070 secs, 3.2953 secs
 resp read:    0.0000 secs, 0.0000 secs, 0.0010 secs
Status code distribution:
 [200] 32918 responses

Diese Zusammenfassung enthält einige interessante Punkte:

32.918 Anfragen wurden 30 Sekunden lang mit etwa 1.000 pro Sekunde gesendet.
Es sind keine Fehler aufgetreten (nur 200 HTTP-Antworten).
Die durchschnittliche Latenz betrug 180 ms.
Die Mindestlatenz betrug 107 ms, der schlimmste Fall 3,3 s.
Die Latenz des 90. Perzentils betrug 244 ms.

Auf dem Tab METRICS in der Cloud Run Console sehen Sie die serverseitige Leistungssteigerung:

9. Bereinigen

Während für Cloud Run keine Kosten anfallen, wenn der Dienst nicht verwendet wird, wird Ihnen dennoch das Speichern des erstellten Container-Images möglicherweise in Rechnung gestellt.

Sie können entweder Ihr GCP-Projekt löschen, um Gebühren zu vermeiden, wodurch die Abrechnung für alle in diesem Projekt verwendeten Ressourcen beendet wird, oder einfach das Container-Image mit folgendem Befehl löschen:

gcloud container images delete $TAG

Verwenden Sie die folgenden Befehle, um Ihre Cloud Run-Dienste zu löschen:

gcloud run services delete hello --platform managed --region $REGION --quiet
gcloud run services delete hello-again --platform managed --region $REGION --quiet

10. Du hast es geschafft!

Glückwunsch – Sie haben erfolgreich eine Cloud Run-Produktionsanwendung erstellt und bereitgestellt. Dabei haben Sie etwas über Container gelernt und darüber, wie Sie eigene Container erstellen können. Außerdem haben Sie gesehen, wie einfach es ist, Ihre Anwendung mit Cloud Run sowohl über das gcloud-Befehlszeilentool als auch über die Cloud Console bereitzustellen. Jetzt weißt du, wie du deine brillanten Kreationen mit der ganzen Welt teilen kannst.

Ich möchte Ihnen noch eine wichtige Frage stellen:

Nachdem Sie Ihre Anwendung in Ihrer Entwicklungsumgebung eingerichtet haben, wie viele Codezeilen mussten Sie ändern, um sie in der Cloud bereitzustellen – mit allen produktionstauglichen Attributen, die Cloud Run bietet?

Die Antwort lautet natürlich null.

Interessante Codelabs...

Weitere coole Funktionen...

Referenzdokumente...

11. Call-to-Action

Wenn Ihnen dieses Codelab gefallen hat und Sie wahrscheinlich mehr Zeit mit Google Cloud verbringen werden, sollten Sie noch heute am Google Cloud Innovators-Programm teilnehmen.

Google Cloud Innovators ist kostenlos und umfasst:

Live-Diskussionen, AMAs und Roadmap-Sitzungen, bei denen Sie das Neueste direkt von Google-Mitarbeitern erfahren
aktuelle Google Cloud-News direkt in Ihrem Posteingang
Digitales Logo und Hintergrund für Videokonferenzen
500 Credits für Labs und Lerninhalte auf Skills Boost

Klicken Sie hier, um sich zu registrieren.