Mit Cloud Run dynamische Inhalte bereitstellen und Mikrodienste hosten

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

Mit Cloud - Run , können Sie eine Anwendung verpackt in einem Behälter Bild bereitstellen. Anschließend können Sie mithilfe von Firebase Hosting HTTPS-Anfragen zum Auslösen Ihrer containerisierten App leiten.

  • Cloud Run unterstützt mehrere Sprachen (einschließlich Go, Node.js, Python und Java), die Ihnen die Flexibilität , um die Programmiersprache und Rahmen Ihrer Wahl zu verwenden.
  • Cloud Run automatisch und horizontal skaliert Ihr Container Bild der empfangenen Anfragen zu bearbeiten, skaliert dann nach unten , wenn die Nachfrage sinkt.
  • Sie zahlen für die CPU, Speicher und während Anforderungsbehandlung verbraucht Vernetzung.

Zum Beispiel Anwendungsfälle und Beispiele für Cloud Run integriert mit Firebase Hosting, besuchen Sie bitte unsere serverless Überblick .


Diese Anleitung zeigt Ihnen, wie Sie:

  1. Schreiben Sie eine einfache Hello World-Anwendung
  2. Containerisieren einer App und Hochladen in Container Registry
  3. Container-Image in Cloud Run bereitstellen
  4. Direkte Hosting-Anfragen an Ihre containerisierte App

Beachten Sie, dass die Leistung des Dienstes dynamische Inhalte zu verbessern, können Sie optional tune Ihre Cache - Einstellungen .

Bevor Sie beginnen

Vor der Verwendung von Cloud - Run, müssen Sie einige erste Aufgaben erledigen, einschließlich der Einrichtung einer Cloud - Abrechnungskonto, auf deren Grundlage die Cloud - Run - API und die Installation der gcloud Kommandozeilen - Tool.

Abrechnung für Ihr Projekt einrichten

Cloud - Run bietet kostenlose Nutzung Quote , aber Sie müssen noch eine haben Cloud - Abrechnungskonto im Zusammenhang mit Ihrem Firebase - Projekt zu verwenden oder ausprobieren Cloud Run.

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

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

  2. Installieren und initialisieren den Cloud - SDK.

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

    gcloud config list

Schritt 1: Schreiben Sie die Beispielanwendung

Beachten Sie, dass Cloud - Run unterstützt viele andere Sprachen zusätzlich zu den Sprachen in der folgenden Probe gezeigt.

gehen

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-go , dann ändern Sie das Verzeichnis in es:

    mkdir helloworld-go
    cd helloworld-go
  2. Erstellen Sie eine neue Datei mit dem Namen helloworld.go , dann fügen Sie den folgenden Code:

    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 ein grundlegendes Webserver, lauscht auf dem Port durch das definierte PORT - Umgebungsvariable.

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

Node.js

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-nodejs , dann ändern Sie das Verzeichnis in es:

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

    Dieser Code erstellt ein grundlegendes Webserver, lauscht auf dem Port durch das definierte PORT - Umgebungsvariable.

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

Python

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-python , dann ändern Sie das Verzeichnis in es:

    mkdir helloworld-python
    cd helloworld-python
  2. Erstellen Sie eine neue Datei mit dem Namen app.py , dann fügen Sie den folgenden Code:

    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 ein grundlegendes Webserver, lauscht auf dem Port durch das definierte PORT - Umgebungsvariable.

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

Java

  1. Installieren Sie Java SE 8 oder höher JDK und ROTATION .

    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.

  2. 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.

  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 ein grundlegendes Webserver, lauscht auf dem Port durch das definierte PORT - Umgebungsvariable.

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

Schritt 2: containerize eine App und laden Sie sie auf Container Registry

  1. Containerize die Beispielanwendung , indem Sie eine neue Datei mit dem Namen Erstellen Dockerfile im selben Verzeichnis wie die Quelldateien. 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 Ihr Dockerfile enthält:

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

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

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

Beachten Sie, dass anstelle des Cloud gebaut, Sie eine lokal installierte Version von Docker verwenden können , um Ihren Container vor Ort zu bauen .

Schritt 3: Stellen Sie die Behälter Bild Cloud Run

  1. Bereitstellen mit dem folgenden Befehl:

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

  2. Bei Aufforderung:

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

  4. Rufen Sie Ihren bereitgestellten Container auf, indem Sie die Dienst-URL in einem Webbrowser öffnen.

Der nächste Schritt führt Sie durch , wie diesen containerisierter App von einem Firebase Hosting URL zuzugreifen , so dass es dynamische Inhalte für Ihre Firebase-gehostete Website zu generieren.

Schritt 4: Direkte Hosting Anfragen an Ihrem containerisierter App

Mit Rewrite - Regeln , können Sie Anfragen richten , die an ein einzelnes Ziel bestimmte Muster entsprechen.

Das folgende Beispiel zeigt , wie alle Anforderungen von der Seite zu lenken /helloworld auf Ihrem Hosting - Website den Start und Ausführen Ihrer auslösen helloworld Container - Instanz.

  1. Stelle sicher das:

    Eine ausführliche Anleitung über die CLI - Installation und Hosting - Initialisierung finden Sie in den ersten Schritten Leitfaden für Hosting .

  2. Öffnen Sie Ihre firebase.json Datei .

  3. Fügen Sie die folgende rewrite - Konfiguration unter dem hosting - Abschnitt:

    "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)
        }
      } ]
    }
    
  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 die folgenden URLs erreichbar:

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

  • Irgendwelche verbundenen benutzerdefinierte Domains :
    CUSTOM_DOMAIN /

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

Lokal testen

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

Nächste Schritte