Dynamische Inhalte bereitstellen und Mikrodienste mit Cloud Run hosten

Wenn Sie Cloud Run mit Firebase Hosting koppeln, werden Ihre oder REST APIs als Mikrodienste erstellen.

Mit Cloud Run können Sie Eine in einem Container-Image verpackte Anwendung bereitstellen Dann verwenden Sie Firebase Hosting, Sie können HTTPS-Anfragen weiterleiten, um Ihre containerisiert.

  • Cloud Run unterstützt mehrere Sprachen (einschließlich Go, Node.js, Python und Java), sodass Sie die Möglichkeit haben, Programmiersprache und Framework Ihrer Wahl.
  • Cloud Run skaliert das Container-Image automatisch horizontal, damit die empfangenen Anfragen bearbeitet werden können, und skaliert es dann wieder herunter, wenn der Bedarf sinkt.
  • Sie zahlen nur für die CPU-, Arbeitsspeicher- und Netzwerkressourcen, die während der Anfrageverarbeitung verbraucht werden.

Beispiele für Anwendungsfälle und Beispiele für Cloud Run, die in Firebase Hosting eingebunden sind, finden Sie in unserer Übersicht über serverlose Funktionen.


In diesem Leitfaden erfahren Sie, wie Sie:

  1. Einfache Hello World-Anwendung schreiben
  2. App containerisieren und in Container Registry hochladen
  3. Stellen Sie das Container-Image in Cloud Run bereit
  4. Hosting-Anfragen an Ihre Containeranwendung weiterleiten

Sie können die Leistung bei der Bereitstellung von dynamischem Content verbessern, indem Sie können Sie optional Ihre Cache-Einstellungen anpassen.

Hinweis

Bevor Sie Cloud Run verwenden können, müssen Sie einige Schritte ausführen: Einrichtung eines Cloud Billing-Kontos, Aktivieren der Cloud Run API und Installation des gcloud-Befehlszeilentools

Abrechnung für Ihr Projekt einrichten

Cloud Run bietet ein kostenloses Nutzungskontingent, aber Sie müssen eine Cloud Billing-Konto die mit Ihrem Firebase-Projekt verknüpft sind, oder probieren Sie Cloud Run aus.

Google Cloud

API aktivieren und SDK installieren

  1. Aktivieren Sie die Cloud Run API in der Google APIs Console:

    1. Öffnen Sie in der Google APIs Console die Seite Cloud Run API.

    2. Wählen Sie Ihr Firebase-Projekt aus, wenn Sie dazu aufgefordert werden.

    3. Klicken Sie auf der API-Seite Cloud Run auf Aktivieren.

  2. Installieren und initialisieren Sie die Cloud SDK

  3. Prüfen Sie, ob das gcloud-Tool für das richtige Projekt konfiguriert ist:

    gcloud config list

Schritt 1: Beispielanwendung schreiben

Hinweis: Cloud Run unterstützt viele weitere Sprachen zusätzlich zu den im folgenden Beispiel gezeigten Sprachen.

Go

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-go und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    mkdir helloworld-go
     
    cd helloworld-go

  2. Erstellen Sie eine neue Datei mit dem Namen helloworld.go und fügen Sie 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

    Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Ihre Anwendung ist fertig und kann in einen Container verlagert und hochgeladen werden: Container Registry

Node.js

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-nodejs und wechseln Sie dann das Verzeichnis einfügen:

    mkdir helloworld-nodejs
     
    cd helloworld-nodejs

  2. 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.20.0"
  }
}

    package.json

  3. Erstellen Sie eine neue Datei mit dem Namen index.js und fügen Sie 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

    Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Ihre Anwendung ist fertig und kann in einen Container verlagert und hochgeladen werden: Container Registry

Python

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-python und wechseln Sie dann das Verzeichnis einfügen:

    mkdir helloworld-python
     
    cd helloworld-python

  2. Erstellen Sie eine neue Datei mit dem Namen app.py und fügen Sie 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

    Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Ihre Anwendung ist fertig und kann in einen Container verlagert und hochgeladen werden: Container Registry

Java

  1. Installieren Sie das Java SE Development Kit Version 8 oder höher und CURL.

    Dieser Schritt ist nur erforderlich, um das neue Webprojekt im nächsten Schritt. Das weiter unten beschriebene Dockerfile wird alle Abhängigkeiten in den Container.

  2. Erstellen Sie in der Console ein neues, leeres Webprojekt mit cURL und Entpacken Sie die folgenden 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 Spring Boot-Projekt erstellt.

  3. SpringBootApplication-Kurs aktualisieren in src/main/java/com/example/helloworld/HelloworldApplication.java von Hinzufügen eines @RestController zur Verarbeitung der /-Zuordnung und Hinzufügen eines @Value, um die Umgebungsvariable TARGET 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

    Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Ihre Anwendung ist fertig und kann in einen Container verlagert und hochgeladen werden: Container Registry

Schritt 2: Anwendung containerisieren und in Container Registry hochladen

  1. Containerisieren Sie die Beispielanwendung, indem Sie im selben Verzeichnis wie die Quelldateien eine neue Datei mit dem Namen Dockerfile erstellen. Kopieren Sie den folgenden Inhalt in die Datei.

    Go

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

ARG TARGETOS
ARG TARGETARCH

# 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=${TARGETOS} GOARCH=${TARGETARCH} 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

  2. Erstellen Sie das Container-Image mit Cloud Build. Dazu führen Sie folgenden Befehl in dem Verzeichnis aus, in dem sich das Dockerfile befindet:

    gcloud builds submit --tag gcr.io/PROJECT_ID/helloworld

    Bei Erfolg wird eine SUCCESS-Meldung mit dem Image-Namen angezeigt
    . (gcr.io/PROJECT_ID/helloworld).

Das Container-Image wird jetzt in Container Registry gespeichert und kann wiederverwendet werden, wenn erwünscht ist.

Anstelle von Cloud Build können Sie eine lokal installierte Version von Docker verwenden, um den Container lokal zu erstellen.

Schritt 3: Container-Image für Cloud Run bereitstellen

  1. Stellen Sie es mit dem folgenden Befehl bereit:

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

  2. Tun Sie Folgendes, wenn Sie dazu aufgefordert werden:

Die beste Leistung erzielen Sie, wenn Sie den Cloud Run-Dienst mit Hosting kennzeichnen. Verwenden Sie dazu die folgenden Regionen:

  • us-west1
  • us-central1
  • us-east1
  • europe-west1
  • asia-east1

Überschreibungen von Hosting in Cloud Run werden unterstützt im folgenden Regionen:

  • asia-east1
  • asia-east2
  • asia-northeast1
  • asia-northeast2
  • asia-northeast3
  • asia-south1
  • asia-south2
  • asia-southeast1
  • asia-southeast2
  • australia-southeast1
  • australia-southeast2
  • europe-central2
  • europe-north1
  • europe-southwest1
  • europe-west1
  • europe-west12
  • europe-west2
  • europe-west3
  • europe-west4
  • europe-west6
  • europe-west8
  • europe-west9
  • me-central1
  • me-west1
  • northamerica-northeast1
  • northamerica-northeast2
  • southamerica-east1
  • southamerica-west1
  • us-central1
  • us-east1
  • us-east4
  • us-east5
  • us-south1
  • us-west1
  • us-west2
  • us-west3
  • us-west4
  • us-west1
  • us-central1
  • us-east1
  • europe-west1
  • asia-east1

  1. Warten Sie einen Moment, bis die Bereitstellung abgeschlossen ist. Im Erfolgsfall wird die Befehlszeile wird die Dienst-URL angezeigt. Beispiel: https://helloworld-RANDOM_HASH-us-central1.a.run.app

  2. Rufen Sie den bereitgestellten Container auf. Dazu öffnen Sie in einem Webbrowser die Dienst-URL.

Im nächsten Schritt erfahren Sie, wie Sie über eine Firebase Hosting URL verwenden, damit dynamische Inhalte für Ihre Von Firebase gehostete Website.

Schritt 4: Hostinganfragen an Containeranwendung weiterleiten

Mit Umschreibregeln können Sie Anfragen, die bestimmten Mustern entsprechen, an ein einzelnes Ziel weiterleiten.

Das folgende Beispiel zeigt, wie alle Anfragen von der Seite weitergeleitet werden /helloworld auf Ihrer Hosting-Website, um den Start und die Ausführung von Ihre helloworld-Containerinstanz.

  1. Sie müssen Folgendes sicherstellen:

    Ausführliche Anweisungen zum Installieren der Befehlszeile und zum Initialisieren Hosting, siehe Startleitfaden für Hosting

  2. Öffnen Sie die Datei firebase.json.

  3. Fügen Sie die folgende rewrite-Konfiguration im Abschnitt hosting 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)
      "pinTag": true              // optional (see note below)
    }
  } ]
}

  4. Stellen Sie die Hostingkonfiguration auf Ihrer Website bereit, indem Sie den folgenden Befehl ausführen: -Befehl aus dem Stammverzeichnis Ihres Projektverzeichnisses:

    firebase deploy --only hosting

Der Container ist jetzt über die folgenden URLs erreichbar:

  • Ihre Firebase-Subdomains:
    PROJECT_ID.web.app/ und PROJECT_ID.firebaseapp.com/

  • Alle verbundenen benutzerdefinierten Domains:
    CUSTOM_DOMAIN/

Besuchen Sie die Hosting-Konfigurationsseite für Weitere Informationen zu Umschreibungsregeln Sie können erfahren Sie auch mehr über die Prioritätsreihenfolge von Antworten für verschiedene Hosting-Konfigurationen.

Lokal testen

Während der Entwicklung können Sie das Container-Image lokal ausführen und testen. Für erhalten Sie auf der Dokumentation zu Cloud Run

Nächste Schritte