Google is committed to advancing racial equity for Black communities. See how.
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

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

Koppeln 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 Anwendung bereitstellen, die in einem Container-Image gepackt ist. Mithilfe von Firebase Hosting können Sie dann HTTPS-Anforderungen anweisen, um Ihre containerisierte App auszulösen.

  • Cloud Run unterstützt mehrere Sprachen (einschließlich Go, Node.js, Python und Java) und bietet Ihnen die Flexibilität, die Programmiersprache und das Framework Ihrer Wahl zu verwenden.
  • Cloud Run skaliert Ihr Container-Image automatisch und horizontal , um die empfangenen Anforderungen zu verarbeiten, und wird dann verkleinert, wenn die Nachfrage abnimmt.
  • Sie zahlen nur für die CPU, den Speicher und das Netzwerk, die während der Anforderungsbearbeitung verbraucht werden.

Informationen zu Anwendungsfällen und Beispielen für Cloud Run, die in Firebase Hosting integriert sind, finden Sie in unserer Übersicht ohne Server .


Diese Anleitung zeigt Ihnen, wie Sie:

  1. Schreiben Sie eine einfache Hello World-Anwendung
  2. Containerisieren Sie eine App und laden Sie sie in die Container-Registrierung hoch
  3. Stellen Sie das Container-Image für Cloud Run bereit
  4. Direkte Hosting-Anfragen an Ihre containerisierte App

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

Bevor Sie beginnen

Bevor Sie Cloud Run verwenden können, müssen Sie einige erste Aufgaben ausführen, darunter das Einrichten eines Abrechnungskontos, das Aktivieren der Cloud Run-API und das Installieren des gcloud .

Richten Sie die Abrechnung für Ihr Projekt ein

Cloud Run bietet zwar ein kostenloses Nutzungskontingent , Sie müssen jedoch noch ein Abrechnungskonto für Ihr Firebase-Projekt haben, um Cloud Run verwenden oder ausprobieren zu können.

Aktivieren Sie die API und installieren Sie das SDK

  1. 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. Wenn Sie dazu aufgefordert werden, wählen Sie Ihr Firebase-Projekt aus.

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

  2. Installieren und initialisieren Sie das Cloud SDK.

Installieren Sie die Beta-Komponente von gcloud

  1. Führen Sie den folgenden Befehl aus, um die Beta-Komponente von gcloud zu installieren:

    gcloud components install beta
  2. Komponenten aktualisieren:

    gcloud components update
  3. Überprüfen Sie, ob das gcloud Tool für das richtige Projekt konfiguriert ist:

    gcloud config list

Schritt 1 : Schreiben Sie die Beispielanwendung

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

Gehen

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-go und wechseln Sie in das 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))
    }
    

    Dieser Code erstellt einen einfachen Webserver, der den durch die Umgebungsvariable PORT definierten Port PORT .

Ihre App ist fertig und kann containerisiert und in die Containerregistrierung hochgeladen werden.

Node.js

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-nodejs und wechseln Sie in das Verzeichnis:

    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.16.4"
      }
    }
    
  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);
    });
    

    Dieser Code erstellt einen einfachen Webserver, der den durch die Umgebungsvariable PORT definierten Port PORT .

Ihre App ist fertig und kann containerisiert und in die Containerregistrierung hochgeladen werden.

Python

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-python und wechseln Sie in das Verzeichnis:

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

    Dieser Code erstellt einen einfachen Webserver, der den durch die Umgebungsvariable PORT definierten Port PORT .

Ihre App ist fertig und kann containerisiert und in die Containerregistrierung hochgeladen werden.

Java

  1. 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. Die Docker-Datei, die später beschrieben wird, lädt alle Abhängigkeiten in den Container.

  2. Erstellen Sie in der Konsole mit cURL ein neues leeres Webprojekt 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 SpringBoot-Projekt erstellt.

  3. Aktualisieren Sie die SpringBootApplication Klasse in src/main/java/com/example/helloworld/HelloworldApplication.java durch eine Zugabe von @RestController die Handhabung / Mapping und fügen Sie auch ein @Value Feld bereitzustellen TARGET - Umgebungsvariable:

    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);
      }
    }
    

    Dieser Code erstellt einen einfachen Webserver, der den durch die Umgebungsvariable PORT definierten Port PORT .

Ihre App ist fertig und kann containerisiert und in die Containerregistrierung hochgeladen werden.

Schritt 2 : Containerisieren Sie eine App und laden Sie sie in die Container-Registrierung hoch

  1. Containerisieren Sie die Beispiel-App, indem Sie eine neue Datei mit dem Namen 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"]
    

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

    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
    

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

  2. Erstellen Sie Ihr Container-Image mit Cloud Build, indem Sie den folgenden Befehl aus dem Verzeichnis ausführen, das Ihre Docker-Datei enthält:

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

    Bei Erfolg wird eine ERFOLGSMELDUNG mit dem Bildnamen angezeigt
    ( gcr.io/ PROJECT_ID /helloworld ).

Das Container-Image wird jetzt in der Container-Registrierung 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 für Cloud Run bereit

  1. Stellen Sie mit dem folgenden Befehl bereit:

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

  2. Wenn Sie dazu aufgefordert werden:

  3. Warten Sie einige Momente, bis die Bereitstellung abgeschlossen ist. Bei Erfolg zeigt die Befehlszeile die Service-URL an. Zum Beispiel: https://helloworld- RANDOM_HASH -us-central1.a.run.app

  4. Besuchen Sie Ihren bereitgestellten Container, indem Sie die Service-URL in einem Webbrowser öffnen.

Der nächste Schritt führt Sie durch den Zugriff auf diese containerisierte App über eine Firebase-Hosting-URL , damit dynamische Inhalte für Ihre von Firebase gehostete Site generiert werden können.

Schritt 4: Direkte Hosting-Anfragen an Ihre containerisierte App

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

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

  1. Stelle sicher das:

    Ausführliche Anweisungen zum Installieren der CLI und zum Initialisieren des Hostings finden Sie im Handbuch Erste Schritte für das Hosting .

  2. Öffnen Sie Ihre Datei firebase.json .

  3. Fügen Sie im hosting Bereich die folgende rewrite :

    "hosting": {
      // ...
    
      // Add the "rewrites" attribute within "hosting"
      "rewrites": [ {
        "source": "**",
        "run": {
          "serviceId": "helloworld",  // "service name" (from when you deployed the container image)
          "region": "us-central1"     // optional (if omitted, default is us-central1)
        }
      } ]
    }
    
  4. 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 folgende URLs erreichbar:

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

  • Alle verbundenen benutzerdefinierten Domänen :
    CUSTOM_DOMAIN /

Weitere Informationen zu Umschreiberegeln finden Sie auf der Hosting-Konfigurationsseite. Sie können sich auch über die Prioritätsreihenfolge der Antworten für verschiedene Hosting-Konfigurationen informieren.

Vor Ort 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