Cloud Run: Ein Leitfaden für die Bereitstellung von containerisierten Apps in GCP

Cloud Run ist die vollständig verwaltete Serverless-Plattform von Google Cloud, mit der du Anwendungen bereitstellen kannst, ohne dich um das Infrastrukturmanagement kümmern zu müssen. Es ist super flexibel und eine gute Wahl für eine Vielzahl von Projekten, von Hobbys bis hin zu Unternehmen.

In diesem Artikel erkläre ich dir, was Cloud Run ist, wie es funktioniert, welche Anwendungsfälle es lösen kann und wie es im Vergleich zu anderen serverlosen Lösungen aussieht. Außerdem zeige ich dir Schritt für Schritt, wie du deine erste Cloud Run-Anwendung bereitstellst!

Undbevor du anfängst: Wenn du ganz neu im Cloud Computing bist, empfehle ich dir unseren Kurs "Einführung in das Cloud Computing ". In diesem Kurs werden die Grundlagen der Cloud erläutert, Schlüsselbegriffe wie Skalierbarkeit und Latenz erklärt und die Vorteile von Cloud-Tools von Anbietern wie GCP behandelt.

Was ist Cloud Run? 

Cloud Run ist eine serverlose Plattform zur Ausführung von Containern, mit der du Anwendungen bereitstellen kannst, ohne dich um das Infrastrukturmanagement kümmern zu müssen. 

Bei herkömmlichen serverbasierten Einsätzen musst du normalerweise virtuelle Maschinen bereitstellen und warten. Cloud Run funktioniert etwas anders und abstrahiert von all dem, um eine vollständig verwaltete Umgebung zu bieten. 

Sie basiert auf Knative (einer Open-Source-Plattform auf Kubernetes-Basis, die serverlose Workloads ermöglicht), was bedeutet, dass deine Anwendung automatisch je nach Bedarf skaliert. Wenn der Datenverkehr zunimmt, schaltet Cloud Run mehr Instanzen frei, um ihn zu bewältigen. Wenn der Verkehr abnimmt, wird er reduziert. Er kann sogar bis auf Null gehen, sodass du nichts bezahlst, wenn deine App nicht aktiv läuft.

Cloud run ist kosteneffizient, aber auch super flexibel. Du kannst Anwendungen einsetzen, die in jeder Sprache geschrieben sind und jedes Framework oder Binary verwenden, solange sie in einem Container laufen. Du kannst mit gängigen Technologien wie Node.js, Python, Go und Java arbeiten, aber auch mit unbekannteren Technologien. In der Praxis bedeutet das, dass Cloud Run Backend-Dienste, APIs, KI-Workloads, Web-Apps und sogar geplante Batch-Jobs betreiben kann. 

Das war für die Sneak Peek. Schauen wir uns die wichtigsten Funktionen von Cloud Run etwas genauer an.

Hauptmerkmale von Cloud Run

Wir haben nur ein paar davon erwähnt, aber hier ist eine vollständige Übersicht über die wichtigsten Funktionen von Cloud Run.

Unabhängig von Sprache und Framework

Einer der größten Vorteile von Cloud Run ist, dass du dich nicht auf eine bestimmte Sprache oder ein bestimmtes Framework festlegen musst. Solange deine Anwendung in einem Container läuft, kannst du sie einsetzen. Wenn du ein Team bist, das mit verschiedenen Technologien arbeitet, kannst du Cloud Run für alle deine Dienste nutzen. Ein Werkzeug für alle Fälle!

Automatische Skalierung

Cloud Run skaliert horizontal und dynamisch auf Basis des Datenverkehrs. Wenn deine Anwendung mehr Anfragen erhält, schaltet Cloud Run automatisch mehr Instanzen frei. Wenn die Nachfrage sinkt, wird sie heruntergefahren, bei Bedarf sogar bis auf Null.

Eingebaute Sicherheit und Compliance

Cloud Run verfügt über automatisches HTTPS für alle bereitgestellten Dienste, eine von Google verwaltete Dienstidentität für eine sichere Authentifizierung, VPC-Konnektivität für private Netzwerke und integrierte Compliance-Zertifizierungen wie SOC 2, ISO 27001 und HIPAA (für Anwendungen im Gesundheitswesen). Im Grunde genommen bist du in guten Händen.

Integration mit Google Cloud-Diensten

Da Cloud Run Teil des Google Cloud-Ökosystems ist, funktioniert es gut mit anderen GCP-Diensten. Du kannst sie ganz einfach mit Cloud SQL für Datenbanken verbinden, Daten mit Pub/Sub streamen, Dateien in Cloud Storage speichern oder sie mit BigQuery, Firebase und AI/ML-Diensten nutzen.

GPU-Unterstützung auf Abruf

Für KI-Workloads bietet Cloud Run jetzt On-Demand-GPU-Unterstützung. Das ist eine großartige Verbesserung für maschinelles Lernen, Videoverarbeitung und wissenschaftliche Berechnungen, weil du damit alle GPU-beschleunigten Workloads ausführen kannst, ohne die Hardware dahinter zu verwalten.

Cloud Run Funktionen: Ein Function-as-a-Service (FaaS) Modell

Wenn du keine vollständigen Container verwalten möchtest, bietet Cloud Run Functions eine vereinfachte, ereignisgesteuerte Möglichkeit, kleine Einzweckfunktionen auszuführen. Es ist vergleichbar mit AWS Lambda oder Google Cloud Functions, läuft aber auf der Infrastruktur von Cloud Run.

So funktioniert Cloud Run: Schritt für Schritt

In diesem Abschnitt zeige ich dir, wie du eine einfache Anwendung in Cloud Run bereitstellst. Ich führe dich durch den Prozess der Containerisierung deiner App, der Bereitstellung in der Cloud Run und der automatischen Skalierung je nach Bedarf.

Wir werden Docker verwenden, um unsere Anwendung zu containerisieren, aber das musst du nicht unbedingt tun. Mehr dazu am Ende.

Schritt 1: Richte deine Umgebung ein

Bevor du etwas bereitstellst, musst du die folgenden Tools installiert haben:

1. Google Cloud SDK: Dies ist einemand-line interface (CLI), mit der du mit Google Cloud-Diensten, einschließlich Cloud Run, interagieren kannst. Du kannst es von hier aus installieren.
2. Docker: Wenn deine App nicht bereits containerisiert ist, brauchst du Docker, um deine App zu verpacken. Installiere Docker von hier aus.
3. Google Cloud Project: Stelle sicher, dass du ein Google Cloud-Projekt eingerichtet hast. Du kannst sie in der Google Cloud Console erstellen.

Schritt 2: Schreibe deinen Anwendungscode

Jetzt wollen wir eine einfache "Hello World"-Node.js-Anwendung schreiben.

Erstelle ein Verzeichnis für deine App:

mkdir hello-world-app
cd hello-world-app

Erstellen Sie eine index.js Datei in dem Verzeichnis mit folgendem Inhalt:

const http = require('http');

const requestListener = (req, res) => {
    res.writeHead(200);
    res.end('Hello, Cloud Run!');
};

const server = http.createServer(requestListener);
server.listen(8080, () => {
    console.log('Server is running on port 8080');
});

Erstellen Sie eine package.json um die Abhängigkeiten für deine App zu definieren:

{
    "name": "hello-world-app",
    "version": "1.0.0",
    "main": "index.js",
    "dependencies": {}
}

Jetzt, wo die Anwendung fertig ist, können wir sie in einen Container packen.

Schritt 3: Containerisierung der Anwendung

Erstelle ein Dockerfile, um das Container-Image zu definieren

Erstelle in deinem Projektverzeichnis eine Datei namens "Dockerfile" mit dem folgenden Inhalt:

# Use the official Node.js image as a base
FROM node:16-alpine

# Set the working directory inside the container
WORKDIR /usr/src/app

# Copy package.json and install dependencies (if any)
COPY package*.json ./

# Copy the rest of the application code
COPY . .

# Expose port 8080 for Cloud Run
EXPOSE 8080

# Start the app
CMD ["node", "index.js"]

Erstelle das Docker-Image

Führe den folgenden Befehl aus, um dein Docker-Image zu erstellen:

docker build -t gcr.io/your-project-id/hello-world-app .

Hinweis: Ersetze your-project-id durch deine Google Cloud Projekt-ID.

Teste das Bild lokal

Du kannst deinen Docker-Container lokal testen, indem du ihn ausführst:

docker run -p 8080:8080 gcr.io/your-project-id/hello-world-app

Besuche http://localhost:8080 in deinem Browser, um zu überprüfen, ob die App läuft.

Schritt 4: Übertrage das Bild an Google Artifact Registry

Aktiviere Artifact Registry für dein Projekt

Wenn du Artifact Registry noch nicht aktiviert hast, führe den folgenden Befehl aus

gcloud services enable artifactregistry.googleapis.com

Hinweis: Um diesen Schritt abzuschließen, musst du die Rechnungsstellung aktivieren!

Erstelle ein Repository in Artifact Registry

Erstelle ein neues Docker-Repository in der Artifact Registry:

gcloud artifacts repositories create hello-world-repo \
--repository-format=docker \
--location=us-central1

Docker bei Artifact Registry authentifizieren

Konfiguriere Docker für die Authentifizierung mit Artifact Registry:

gcloud auth configure-docker us-central1-docker.pkg.dev

Markiere das Docker-Image für Artifact Registry

Markiere dein Docker-Image mit der URL des Artifact Registry-Repository:

docker tag gcr.io/your-project-id/hello-world-app us-central1-docker.pkg.dev/your-project-id/hello-world-repo/hello-world-app

Übertrage das Bild in die Artefaktregistrierung

Schiebe das getaggte Docker-Image in dein Artifact Registry Repository:

docker push us-central1-docker.pkg.dev/your-project-id/hello-world-repo/hello-world-app

Schritt 5: Bereitstellung in der Cloud Ausführen

Sobald dein Bild in der Artifact Registryübertragen wurde, kannst du es in der Cloud Ausführen direkt von Artifact Registry aus bereitstellen.

Stelle dein Image in der Cloud Run bereit mit folgendem Befehl:

gcloud run deploy hello-world-app \
--image us-central1-docker.pkg.dev/your-project-id/hello-world-repo/hello-world-app \
--platform managed \
--region us-central1 \
--allow-unauthenticated

• hello-world-app: Dies ist der Name deines Cloud Run-Dienstes.
• us-central1-docker.pkg.dev/your-project-id/hello-world-repo/hello-world-app: Die URL für dein Bild, das in Artifact Registry gespeichert ist.
• --platform managed: Stellt sicher, dass der Einsatz die vollständig verwaltete Plattform von Cloud Run nutzt (kein GKE-Cluster).
• --region us-central1: Gib die Region an, in der Cloud Run den Dienst bereitstellen soll.
• --allow-unauthenticated: Dies ermöglicht den öffentlichen Zugang zu dem Dienst. Wenn du einen eingeschränkten Zugang benötigst, kannst du dieses Kennzeichen entsprechend anpassen.

Nachdem du diesen Befehl ausgeführt hast, wird Cloud Run deine containerisierte Anwendung bereitstellen und dir eine URL für den Zugriff darauf geben.

Und wir sind alle fertig! Schau in der GCP-Konsole nach, dort solltest du deine neue Instanz sehen.

Schritt 6: Aufräumen

Um laufende Kosten zu vermeiden, solltest du deinen Dienst löschen, sobald du mit dem Testen fertig bist.

1. Lösche den Cloud Run Dienst

Führe den folgenden Befehl aus, um deinen eingesetzten Cloud Run-Dienst zu löschen:

gcloud run services delete hello-world-app --region us-central1

Dadurch wird die Cloud Run-Instanz entfernt, aber das Container-Image wird nicht gelöscht.

2. Das Artefaktregistrierungs-Image löschen

So entfernen Sie das Bild aus dem Artefakt-Registerlistest du zuerst die Bilder auf:

gcloud artifacts docker images list us-central1-docker.pkg.dev/your-project-id/hello-world-repo

Lösche das Bild dann mit:

gcloud artifacts docker images delete us-central1-docker.pkg.dev/your-project-id/hello-world-repo/hello-world-app --delete-tags

Jetzt ist auch dein Artefaktregister aufgeräumt.

3. Lösche das Artifact Registry Repository (falls nicht mehr benötigt)

Wenn du das Artifact Registry Repository vollständig entfernen möchtest, führe aus:

gcloud artifacts repositories delete hello-world-repo --location=us-central1

Dieser Schritt ist nur notwendig, wenn du mit dem Repository komplett fertig bist, ansonsten kannst du es für zukünftige Einsätze wiederverwenden.

4. (Optional) Lösche das Google Cloud Projekt

Wenn dies ein Testprojekt war und du es nicht mehr brauchst, kannst du das gesamte Projekt löschen, um alle zugehörigen Ressourcen zu entfernen:

gcloud projects delete your-project-id

Einsatz von Quellen

Weißt du noch, als ich sagte, dass du deine App nicht immer manuell containerisieren musst?

Cloud Run unterstützt jetzt Source Deployments, d.h. es kann den Container für dich aus deinem Quellcode mit Cloud Build bauen.

Du kannst den Befehl verwenden:

gcloud run deploy hello-world-app \
--source . \
--region us-central1 \
--allow-unauthenticated

Cloud Build erkennt automatisch die Sprache deiner Anwendung (Node.js, Python, Go, Java usw.), erstellt ein Container-Image für dich und speichert es in der Artifact Registry. Cloud Run setzt das erstellte Image dann genauso ein, als hättest du manuell einen Container erstellt. Für einfache Anwendungen mit unterstützten Sprachen (Node.js, Python, Go, Java usw.) würde ich dies auf jeden Fall empfehlen, aber nicht, wenn du die volle Kontrolle über den Container brauchst (z. B. benutzerdefinierte Abhängigkeiten, Anpassungen auf Betriebssystemebene, mehrstufige Builds).

Tipps zur effizienten Nutzung von Cloud Run

Okay, die Bereitstellung einer App in Cloud Run ist also ziemlich einfach, aber damit sie effizient läuft, ist ein bisschen Feintuning nötig. Als ich anfing, es zu benutzen, habe ich eine Phase des Ausprobierens durchgemacht, und das habe ich gelernt:

1. Kaltstarts sind real

Vor allem, wenn du mit einem großen Containerbild arbeitest. Je kleiner dein Bild ist, desto schneller dreht sich dein Dienst. Die Verwendung eines minimalen Basis-Images wie distroless kann einen großen Unterschied machen. Wenn du Python-Anwendungen entwickelst, solltest du slim Versionen der offiziellen Images verwenden. Wenn dir die Kosten nicht so wichtig sind, kannst du die Mindestanzahl der Instanzen auf 1 setzen.

2. Die beste Variable, mit der du spielen kannst, ist die Anzahl der gleichzeitigen Anfragen

Mit Cloud Run kann jede Instanz mehrere Anfragen gleichzeitig bearbeiten, aber die Standardeinstellung (80 Anfragen pro Container) ist oft nicht optimal. Bei CPU-intensiven Aufgaben habe ich die Erfahrung gemacht, dass eine Verringerung der Gleichzeitigkeit auf 1 oder 2 die Dinge viel reibungsloser macht. Auf der anderen Seite können APIs in der Regel eine höhere Zahl verarbeiten. Je höher die Zahl, desto mehr kannst du die Anzahl der benötigten Instanzen reduzieren und desto weniger zahlst du. Es lohnt sich also, mit verschiedenen Werten zu experimentieren, um den Sweet Spot für deine App zu finden.

3. Setze deiner Instanz Grenzen!

Super hilfreich, wenn jemand (ich) beschließt, ein paar Lasttests zu machen und eine dumme Anzahl von Anfragen startet. Ich habe diese Lektion gelernt, damit du sie nicht lernen musst. Bitte gib die maximale Anzahl der Instanzen an.

4. Stelle sicher, dass du den richtigen Leuten Zugang zu deiner Instanz gewährst

Standardmäßig kann jeder mit der URL auf die Cloud Run-Dienste zugreifen , was für schnelle Demos gut ist, aber nicht so gut für die Produktion. Wenn deine App nicht für die Öffentlichkeit bestimmt ist, sperre sie mit IAM-Berechtigungen. 

5. Cloud Logging und Cloud Trace werden zu deinen besten Freunden

Wenn du, wie ich, dazu neigst, Probleme per SSH in virtuellen Maschinen zu beheben, wirst du enttäuscht sein. Die Cloud Run-Protokolle werden direkt in das Dashboard von Google Cloud gestreamt, sodass du dort alles sehen kannst. Achte darauf, dass du deine Anwendung mit einer strukturierten Protokollierung versiehst, das macht die Fehlersuche viel einfacher.

Cloud Run Anwendungsfälle

Wir haben über einige Anwendungsfälle von Cloud Run gesprochen, z. B. die Ausführung von Webanwendungen, APIs oder Cron-Jobs, aber es gibt natürlich noch viel mehr.

Video- und Bildanalyse

Du kannst ein Bilderkennungsmodell einsetzen, um hochgeladene Bilder in Echtzeit für eine Social-Media-Plattform zu verarbeiten, oder Videotranskodierungsaufgaben ausführen, wenn ein Video hochgeladen wird. Cloud Run kann mit seiner automatischen Skalierung Nachfragespitzen (z. B. virale Inhalte) bewältigen und gleichzeitig die Kosteneffizienz bei geringer Nachfrage sicherstellen.

Quelle: Google Cloud

Stream-Verarbeitung in Echtzeit

Stell dir vor, du baust ein System, das das Nutzerverhalten auf einem Online-Marktplatz überwacht. Durch die Verarbeitung von Ereignisströmen aus Pub/Sub oder BigQuery kannst du sofort Aktionen auf der Grundlage von Nutzeraktivitäten auslösen, z. B. das Versenden von Push-Benachrichtigungen oder die Analyse von Trends in Echtzeit. Cloud Run skaliert automatisch nach oben, um die eingehenden Ereignisse in Spitzenzeiten zu bewältigen, und nach unten, wenn das Volumen der Streams abnimmt.

Quelle: Google Cloud

Dateiverarbeitung in Echtzeit

Ein Anwendungsfall könnte die Echtzeitanalyse von Logdateien in einem großen Unternehmen sein. Sobald eine Protokolldatei in den Cloud-Speicher hochgeladen wird, kann Cloud Run einen Container auslösen, der die Datei analysiert und die Ergebnisse speichert, wobei die Skalierung dynamisch auf der Grundlage der Dateigröße und der Komplexität der Verarbeitungsaufgabe erfolgt.

Quelle: Google Cloud

Serverlose IoT-Backends

Cloud Run ist ideal für die Abwicklung von Backend-Diensten für IoT-Anwendungen. Bei einer IoT-Lösung, die Umweltdaten von Tausenden von Sensoren erfasst, kann Cloud Run beispielsweise die eingehenden Daten von jedem Gerät in Echtzeit verarbeiten.

Quelle: Google Cloud

Google Cloud Run Preisgestaltung 

Cloud Run folgt einem Pay-as-you-go-Modell, d.h. du zahlst nur für die Rechenressourcen, die genutzt werden, während deine Anwendung aktiv läuft. Wenn deine App keine Anfragen bearbeitet, kann sie auf Null heruntergefahren werden, was bedeutet, dass du keine unnötigen Kosten zahlst.

Aufschlüsselung der Preise

Ab März 2025 basieren die Gebühren von Cloud Run auf zwei Hauptfaktoren:

Diese Preise gelten für die instanzbasierte Abrechnung, aber bei der anforderungsbasierten Abrechnung funktioniert es anders. Der oben genannte Preis und die kostenlose Stufe unterscheiden sich auch leicht je nach Region, in der du dich befindest, also sieh auf der offiziellen Google Cloud-Seite nach, um die genauen Zahlen zu erfahren. Sie haben einen Preisrechner, der dir hilft, die Kosten zu berechnen, und sie bieten auch Rabatte für den engagierten Einsatz.

Kleiner Tipp: Der Datenverkehr mit anderen Google Cloud-Diensten in derselben Region ist kostenlos, also versuche, Cloud Storage, Cloud SQL oder Pub/Sub anstelle von externen Diensten für den Datenaustausch zu nutzen.

Cloud Run vs. Cloud Run Funktionen 

Google bietet zwei Optionen für serverloses Computing an: Cloud Run und Cloud Run Functions (früher Cloud Functions). Beide ermöglichen es dir, Code auszuführen, ohne die Infrastruktur zu verwalten, aber sie unterscheiden sich leicht.

• ✅ Du brauchst die volle Kontrolle über die Laufzeit und die Abhängigkeiten.
• ✅ Du betreibst einen Webservice, eine API oder einen Microservice, der dauerhafte Anfragen verarbeitet.
• ✅ Du willst eine bestehende containerisierte Anwendung mit minimalen Änderungen einsetzen.
• ✅ Du brauchst Hintergrundverarbeitung oder lang laufende Aufgaben (wie KI-Inferenz, Batch-Jobs).

Wann du Cloud Run-Funktionen verwenden solltest

• ✅ Du willst einfache, ereignisgesteuerte Funktionen, die bei Ereignissen wie Pub/Sub-Nachrichten oder Cloud Storage Uploads ausgelöst werden.
• ✅ Du bearbeitest kurzlebige Vorgänge wie das Versenden von Benachrichtigungen, die Verarbeitung kleiner Aufträge oder die Umwandlung von Daten.
• ✅ Du willst keine Container verwalten und bevorzugst vorgefertigte Laufzeiten für JavaScript, Python, Go, etc.

Du musst dich aber nicht unbedingt entscheiden, du kannst auch beides zusammen verwenden! Dein Cloud Run-Backend könnte zum Beispiel Cloud Run-Funktionen für bestimmte Aufgaben wie das Senden von E-Mails oder die asynchrone Verarbeitung von Bildern auslösen.

Vergleiche mit anderen Google Cloud-Diensten

Wir haben Cloud Run und Cloud Run Functions ziemlich gründlich verglichen, aber es gibt vielleicht noch ein paar andere Google Cloud-Dienste, die hier erwähnt werden sollten: GKE und App Engine.

Fazit

Jetzt, wo du alles über Cloud Run weißt, kannst du deine erste Instanz starten oder dir andere Google Cloud Services ansehen, um den für dich richtigen Grad an Kontrolle und Automatisierung zu finden!