Diese Seite wurde von der Cloud Translation API übersetzt.

Stellen Sie dynamische Inhalte bereit und hosten Sie Microservices mit Cloud Run

Kombinieren Sie Cloud Run mit Firebase Hosting, um Ihre dynamischen Inhalte zu generieren und bereitzustellen oder REST-APIs als Microservices zu erstellen.

Mit Cloud Run können Sie eine in einem Container-Image gepackte Anwendung bereitstellen. Anschließend können Sie mithilfe von Firebase Hosting HTTPS-Anforderungen leiten, um Ihre containerisierte Anwendung auszulösen.

Cloud Run unterstützt mehrere Sprachen (einschließlich Go, Node.js, Python und Java), sodass Sie die Programmiersprache und das Framework Ihrer Wahl flexibel verwenden können.
Cloud Run skaliert Ihr Container-Image automatisch und horizontal , um die empfangenen Anfragen zu verarbeiten, und skaliert dann nach unten, wenn die Nachfrage sinkt.
Sie zahlen nur für die CPU, den Arbeitsspeicher und das Netzwerk, die während der Anfragebearbeitung verbraucht werden.

Beispiele für Anwendungsfälle und Beispiele für Cloud Run integriert mit Firebase Hosting finden Sie in unserer serverlosen Übersicht .

Diese Anleitung zeigt Ihnen, wie Sie:

Schreiben Sie eine einfache „Hello World“-Anwendung
Containerisieren Sie eine App und laden Sie sie in Container Registry hoch
Stellen Sie das Container-Image in Cloud Run bereit
Direkte Hosting-Anfragen an Ihre Container-App

Beachten Sie, dass Sie optional Ihre Cache-Einstellungen optimieren können, um die Leistung beim Bereitstellen dynamischer Inhalte zu verbessern.

Bevor Sie beginnen

Bevor Sie Cloud Run verwenden, müssen Sie einige anfängliche Aufgaben ausführen, darunter das Einrichten eines Cloud-Rechnungskontos, das Aktivieren der Cloud Run-API und das Installieren des gcloud -Befehlszeilentools.

Richten Sie die Abrechnung für Ihr Projekt ein

Cloud Run bietet ein kostenloses Nutzungskontingent , aber Sie müssen dennoch ein Cloud-Rechnungskonto haben, das mit Ihrem Firebase-Projekt verknüpft ist, um Cloud Run zu verwenden oder auszuprobieren.

Aktivieren Sie die API und installieren Sie das SDK

Aktivieren Sie die Cloud Run API in der Google APIs-Konsole:
1. Öffnen Sie die Cloud Run API-Seite in der Google APIs-Konsole.
2. Wählen Sie bei Aufforderung Ihr Firebase-Projekt aus.
3. Klicken Sie auf der Seite Cloud Run API auf Aktivieren.
Installieren und initialisieren Sie das Cloud SDK.
Überprüfen Sie, ob das gcloud Tool für das richtige Projekt konfiguriert ist:
```
gcloud config list
```

Schritt 1 : Musterantrag schreiben

Beachten Sie, dass Cloud Run zusätzlich zu den im folgenden Beispiel gezeigten Sprachen viele andere Sprachen unterstützt.

gehen

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-go und wechseln Sie dann in das Verzeichnis:
```
mkdir helloworld-go
```
```
cd helloworld-go
```

Erstellen Sie eine neue Datei mit dem Namen helloworld.go und fügen Sie dann den folgenden Code hinzu:

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func handler(w http.ResponseWriter, r *http.Request) {
	log.Print("helloworld: received a request")
	target := os.Getenv("TARGET")
	if target == "" {
		target = "World"
	}
	fmt.Fprintf(w, "Hello %s!\n", target)
}

func main() {
	log.Print("helloworld: starting server...")

	http.HandleFunc("/", handler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("helloworld: listening on port %s", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}
helloworld.go

Dieser Code erstellt einen einfachen Webserver, der den Port abhört, der durch die Umgebungsvariable PORT definiert ist.

Ihre App ist fertig und kann containerisiert und in Container Registry hochgeladen werden.

Node.js

Erstellen Sie ein neues Verzeichnis namens helloworld-nodejs und wechseln Sie dann in das Verzeichnis:
```
mkdir helloworld-nodejs
```
```
cd helloworld-nodejs
```

Erstellen Sie eine package.json -Datei mit folgendem Inhalt:

{
  "name": "knative-serving-helloworld",
  "version": "1.0.0",
  "description": "Simple hello world sample in Node",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "Apache-2.0",
  "dependencies": {
    "express": "^4.18.2"
  }
}
package.json

Erstellen Sie eine neue Datei namens index.js und fügen Sie dann den folgenden Code hinzu:

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}!\n`);
});

const port = process.env.PORT || 8080;
app.listen(port, () => {
  console.log('Hello world listening on port', port);
});
index.js

Dieser Code erstellt einen einfachen Webserver, der den Port abhört, der durch die Umgebungsvariable PORT definiert ist.

Ihre App ist fertig und kann containerisiert und in Container Registry hochgeladen werden.

Python

Erstellen Sie ein neues Verzeichnis namens helloworld-python und wechseln Sie dann in das Verzeichnis:
```
mkdir helloworld-python
```
```
cd helloworld-python
```

Erstellen Sie eine neue Datei mit dem Namen app.py und fügen Sie dann den folgenden Code hinzu:

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)))
app.py

Dieser Code erstellt einen einfachen Webserver, der den Port abhört, der durch die Umgebungsvariable PORT definiert ist.

Ihre App ist fertig und kann containerisiert und in Container Registry hochgeladen werden.

Java

Installieren Sie Java SE 8 oder höher JDK und CURL .
Beachten Sie, dass wir dies nur tun müssen, um im nächsten Schritt das neue Webprojekt zu erstellen. Das später beschriebene Dockerfile lädt alle Abhängigkeiten in den Container.

Erstellen Sie in der Konsole ein neues leeres Webprojekt mit cURL und entpacken Sie dann die Befehle:

curl https://start.spring.io/starter.zip \
    -d dependencies=web \
    -d name=helloworld \
    -d artifactId=helloworld \
    -o helloworld.zip

unzip helloworld.zip

Dadurch wird ein SpringBoot-Projekt erstellt.

Aktualisieren Sie die SpringBootApplication -Klasse in src/main/java/com/example/helloworld/HelloworldApplication.java , indem Sie einen @RestController hinzufügen, um die / @RestController zu handhaben, und außerdem ein @Value -Feld hinzufügen, um die TARGET -Umgebungsvariable bereitzustellen:

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);
  }
}
HelloworldApplication.java

Dieser Code erstellt einen einfachen Webserver, der den Port abhört, der durch die Umgebungsvariable PORT definiert ist.

Ihre App ist fertig und kann containerisiert und in Container Registry hochgeladen werden.

Schritt 2 : Containerisieren Sie eine App und laden Sie sie in Container Registry hoch

Containerisieren Sie die Beispiel-App, indem Sie eine neue Datei namens Dockerfile im selben Verzeichnis wie die Quelldateien erstellen. Kopieren Sie den folgenden Inhalt in Ihre Datei.

gehen

# Use the official Golang image to create a build artifact.
# This is based on Debian and sets the GOPATH to /go.
FROM golang:1.13 as builder

# Create and change to the app directory.
WORKDIR /app

# Retrieve application dependencies using go modules.
# Allows container builds to reuse downloaded dependencies.
COPY go.* ./
RUN go mod download

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

# Build the binary.
# -mod=readonly ensures immutable go.mod and go.sum in container builds.
RUN CGO_ENABLED=0 GOOS=linux go build -mod=readonly -v -o server

# Use the official Alpine image for a lean production container.
# https://hub.docker.com/_/alpine
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM alpine:3
RUN apk add --no-cache ca-certificates

# Copy the binary to the production image from the builder stage.
COPY --from=builder /app/server /server

# Run the web service on container startup.
CMD ["/server"]
Dockerfile

Node.js

# Use the official lightweight Node.js 12 image.
# https://hub.docker.com/_/node
FROM node:12-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" ]
Dockerfile

Python

# Use the official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.7-slim

# Allow statements and log messages to immediately appear in the Knative logs
ENV PYTHONUNBUFFERED True

# 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 --timeout 0 app:app
Dockerfile

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 the Official OpenJDK image for a lean production stage of our multi-stage build.
# https://hub.docker.com/_/openjdk
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM openjdk:8-jre-alpine

# 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", "-jar", "/helloworld.jar"]
Dockerfile

Erstellen Sie Ihr Container-Image mit Cloud Build, indem Sie den folgenden Befehl aus dem Verzeichnis ausführen, das Ihr Dockerfile enthält:
```
gcloud builds submit --tag gcr.io/PROJECT_ID/helloworld
```
Bei Erfolg sehen Sie eine ERFOLG-Meldung mit dem Bildnamen
( gcr.io/ PROJECT_ID /helloworld ).

Das Container-Image wird nun in Container Registry gespeichert und kann bei Bedarf wiederverwendet werden.

Beachten Sie, dass Sie anstelle von Cloud Build eine lokal installierte Version von Docker verwenden können, um Ihren Container lokal zu erstellen.

Schritt 3 : Stellen Sie das Container-Image in Cloud Run bereit

Stellen Sie mit dem folgenden Befehl bereit:

gcloud run deploy --image gcr.io/PROJECT_ID/helloworld

Wenn Sie dazu aufgefordert werden:
- Wählen Sie eine Region aus (z. B. us-central1 )
- Bestätigen Sie den Dienstnamen (z. B. helloworld )
- Antworten Sie mit Y , um nicht authentifizierte Aufrufe zuzulassen
Wichtig: Merken Sie sich die Region und den Dienstnamen, damit Sie diese Werte später beim Definieren der region bzw. der serviceID in der firebase.json Umschreibungsregel verwenden können.
Warten Sie einen Moment, bis die Bereitstellung abgeschlossen ist. Bei Erfolg zeigt die Befehlszeile die Dienst-URL an. Beispiel https://helloworld- RANDOM_HASH -us-central1.a.run.app
Rufen Sie Ihren bereitgestellten Container auf, indem Sie die Dienst-URL in einem Webbrowser öffnen.

Im nächsten Schritt erfahren Sie, wie Sie über eine Firebase-Hosting-URL auf diese Container-App zugreifen, damit sie dynamische Inhalte für Ihre von Firebase gehostete Website generieren kann.

Schritt 4: Leiten Sie Hosting-Anfragen an Ihre containerisierte Anwendung weiter

Mit Rewrite-Regeln können Sie Anforderungen, die mit bestimmten Mustern übereinstimmen, an ein einzelnes Ziel leiten.

Das folgende Beispiel zeigt, wie Sie alle Anfragen von der Seite /helloworld auf Ihrer Hosting-Site weiterleiten, um den Start und die Ausführung Ihrer helloworld Containerinstanz auszulösen.

Stelle sicher das:
- Sie haben die neueste Version der Firebase CLI .
- Sie haben Firebase Hosting initialisiert.
Ausführliche Anweisungen zum Installieren der Befehlszeilenschnittstelle und zum Initialisieren von Hosting finden Sie im Handbuch „Erste Schritte“ für Hosting .
Öffnen Sie Ihre firebase.json -Datei .

Fügen Sie die folgende rewrite -Konfiguration im hosting Abschnitt hinzu:

"hosting": {
  // ...

  // Add the "rewrites" attribute within "hosting"
  "rewrites": [ {
    "source": "/helloworld",
    "run": {
      "serviceId": "helloworld",  // "service name" (from when you deployed the container image)
      "region": "us-central1"     // optional (if omitted, default is us-central1)
    }
  } ]
}

Stellen Sie Ihre Hosting-Konfiguration auf Ihrer Site bereit, indem Sie den folgenden Befehl im Stammverzeichnis Ihres Projektverzeichnisses ausführen:
```
firebase deploy
```

Ihr Container ist jetzt über die folgenden URLs erreichbar:

Ihre Firebase-Subdomains:
PROJECT_ID .web.app/ und PROJECT_ID .firebaseapp.com/
Alle verbundenen benutzerdefinierten Domänen :
CUSTOM_DOMAIN /

Besuchen Sie die Hosting-Konfigurationsseite für weitere Details zu Rewrite-Regeln . Sie können sich auch über die Prioritätsreihenfolge von Antworten für verschiedene Hosting-Konfigurationen informieren.

Lokal testen

Während der Entwicklung können Sie Ihr Container-Image lokal ausführen und testen. Ausführliche Anweisungen finden Sie in der Cloud Run-Dokumentation .

Nächste Schritte

Richten Sie das Caching Ihrer dynamischen Inhalte auf einem globalen CDN ein.
Interagieren Sie mit anderen Firebase-Diensten über das Firebase Admin SDK .
Erfahren Sie mehr über Cloud Run, einschließlich detaillierter Anleitungen zum Einrichten, Verwalten und Konfigurieren von Containern.
Überprüfen Sie die Preise sowie die Kontingente und Limits für Cloud Run.