הגש תוכן דינמי ושירותי מיקרו שירותים באמצעות Cloud Run

חבר Cloud Run עם Firebase Hosting כדי ליצור ולשרת את התוכן הדינמי שלך או לבנות ממשקי API של REST כשירותי מיקרו.

באמצעות ענן הפעלה , תוכל לפרוס יישומים ארוזים תמונת מיכל. לאחר מכן, באמצעות Firebase Hosting, תוכל להפנות בקשות HTTPS להפעיל את האפליקציה המכילה שלך.

  • ענן הפעלה תומכת במספר שפות (כולל Go, Node.js, Python, ו- Java), נותן לך את הגמישות להשתמש בשפת תכנות מסגרת על פי בחירתך.
  • ענן הפעלה אוטומטית ואופקי קשקשי תמונת מיכל שלך להתמודד עם הבקשות שהתקבלו, אז תמזער כאשר ביקוש יורד.
  • אתה רק לשלם עבור המעבד, הזיכרון, ואת הרשתות נצרך במהלך הטיפול בבקשה.

לעיון בדוגמאות לשימוש למשל ודוגמאות עבור ענן הפעלה משולבת עם Firebase אירוח, בקר סקירה ללא שרת .


מדריך זה מראה לכם כיצד:

  1. כתוב אפליקציית Hello World פשוטה
  2. מכיל אפליקציה והעלה אותה לרישום המכולות
  3. לפרוס את תמונת המכולה ל- Cloud Run
  4. בקשות אירוח ישירות לאפליקציה המכילה שלך

שים לב כי על מנת לשפר את הביצועים של הצגת תוכן דינמי, יש לך אפשרות לכוון שלך הגדרות מטמון .

לפני שאתה מתחיל

לפני שימוש ענן הפעלה, אתה צריך להשלים כמה משימות ראשוניות, כולל הגדרת חשבון חיוב ענן, המאפשר API ענן ההפעלה, והתקנה של gcloud כלי שורת פקוד.

הגדר חיוב עבור הפרויקט שלך

ענן הפעלה מציעה ממכסת שימוש בחינם , אבל אתה עדיין צריך להיות בעל חשבון חיוב ענן קשור לפרויקט Firebase שלך כדי שימוש או לנסות ענן הפעלה.

הפעל את ה- API והתקן את ה- SDK

  1. הפעל את ה- Cloud Run API במסוף Google APIs:

    1. פתח את דף API ענן הפעלה במסוף API של Google.

    2. כשתתבקש, בחר את פרויקט Firebase שלך.

    3. לחץ אפשר בדף API ענן ההפעלה.

  2. התקן לאתחל ענן SDK.

  3. בדוק כי gcloud שהכלי מוגדר לפרויקט הנכון:

    gcloud config list

שלב 1: כתוב את היישום לדוגמה

הערה כי ענן הפעלה תומכת בשפות רבות אחרות בנוסף בשפות המוצגות במדגם הבא.

ללכת

  1. צור בשם ספרייה חדשה helloworld-go , ואז שינוי ספרייה לתוכו:

    mkdir helloworld-go
    cd helloworld-go
  2. צור חדש בשם קובץ helloworld.go , ולאחר מכן להוסיף את הקוד הבא:

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

    קוד זה יוצר שרת אינטרנט בסיסי שמאזין על היציאה שהוגדר על ידי PORT משתנה הסביבה.

האפליקציה שלך הסתיימה ומוכנה לאריזת מכולות ולהעלות לרישום המכולות.

Node.js

  1. צור ספרייה חדשה בשם helloworld-nodejs , ספריית שינוי אז לתוכו:

    mkdir helloworld-nodejs
    cd helloworld-nodejs
  2. צור package.json קובץ עם התכנים הבאים:

    {
      "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. יצירת קובץ חדש בשם index.js , ולאחר מכן להוסיף את הקוד הבא:

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

    קוד זה יוצר שרת אינטרנט בסיסי שמאזין על היציאה שהוגדר על ידי PORT משתנה הסביבה.

האפליקציה שלך הסתיימה ומוכנה לאריזת מכולות ולהעלות לרישום המכולות.

פִּיתוֹן

  1. צור בשם ספרייה חדשה helloworld-python , ספריית שינוי אז לתוכו:

    mkdir helloworld-python
    cd helloworld-python
  2. יצירת קובץ חדש בשם app.py , ולאחר מכן להוסיף את הקוד הבא:

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

    קוד זה יוצר שרת אינטרנט בסיסי שמאזין על היציאה שהוגדר על ידי PORT משתנה הסביבה.

האפליקציה שלך הסתיימה ומוכנה לאריזת מכולות ולהעלות לרישום המכולות.

ג'אווה

  1. התקן 8 SE Java או במאוחר JDK ו CURL .

    שים לב שעלינו לעשות זאת רק כדי ליצור את פרויקט האינטרנט החדש בשלב הבא. ה- Dockerfile, המתואר בהמשך, יטען את כל התלות במיכל.

  2. מהמסוף, צור פרויקט אינטרנט ריק חדש באמצעות cURL ואז פתח את הפקודות:

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

    זה יוצר פרויקט SpringBoot.

  3. עדכן את SpringBootApplication בכיתה ב src/main/java/com/example/helloworld/HelloworldApplication.java ידי הוספת @RestController לטפל / מיפוי וכן יוסיף @Value שדה כדי לספק את TARGET משתנה הסביבה:

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

    קוד זה יוצר שרת אינטרנט בסיסי שמאזין על היציאה שהוגדר על ידי PORT משתנה הסביבה.

האפליקציה שלך הסתיימה ומוכנה לאריזת מכולות ולהעלות לרישום המכולות.

שלב 2: שיכלא אפליקציה ולהעלות אותו מיכל הרישום

  1. שתכלא את היישום מדגם על ידי יצירת קובץ חדש בשם Dockerfile באותה ספרייה כמו קבצי המקור. העתק את התוכן הבא לקובץ שלך.

    ללכת

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

    פִּיתוֹן

    # 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
    

    ג'אווה

    # 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. בנה את תמונת המכולה שלך באמצעות Cloud Build על ידי הפעלת הפקודה הבאה מהספרייה המכילה את Dockerfile שלך:

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

    לאחר ההצלחה, תראה הודעת SUCCESS המכילה את שם התמונה
    ( gcr.io/ PROJECT_ID /helloworld ).

תמונת המכולה מאוחסנת כעת ברישום המכולות וניתן להשתמש בה מחדש במידת הצורך.

שים לב, במקום ענן Build, אתה יכול להשתמש בגרסה מותקנת מקומי של דוקר כדי לבנות מיכל שלך באופן מקומי .

שלב 3: לפרוס את תמונת מיכל ענן Run

  1. הפעל באמצעות הפקודה הבאה:

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

  2. כאשר תתבקש:

  3. המתן מספר רגעים עד להשלמת הפריסה. לאחר ההצלחה, שורת הפקודה מציגה את כתובת האתר של השירות. לדוגמה: https://helloworld- RANDOM_HASH -us-central1.a.run.app

  4. בקר במיכל הפרוס שלך על ידי פתיחת כתובת האתר של השירות בדפדפן אינטרנט.

השלב הבא ידריך אותך כיצד לגשת אפליקציה במכולות זה מכתובת URL אירוח Firebase כך שהוא יכול ליצור תוכן דינמי עבור אתר Firebase המארחת שלך.

שלב 4: בקשות אירוח ישירות האפליקציה במכולות שלך

עם כללי שכתוב , אתה יכול לכוון בקשות תואמי דפוסים מסוימים אל יעד יחיד.

המופעים הדוגמה הבאה איך לכוון את כל הבקשות מהדף /helloworld באתר אירוח, כדי להפעיל את ההפעלה והפעלה של שלך helloworld למשל מיכל.

  1. תוודא ש:

    לקבלת הוראות מפורטות לגבי התקנת CLI ו אתחול אירוח, לראות את המדריך צא לדרך אירוח .

  2. פתח שלכם firebase.json קובץ .

  3. מוסיף את הבאים rewrite התצורה תחת hosting הסעיף:

    "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. לפרוס את תצורת האירוח לאתר שלך על ידי הפעלת הפקודה הבאה משורש ספריית הפרויקטים שלך:

    firebase deploy

כעת ניתן לגשת למיכל שלך באמצעות כתובות האתרים הבאות:

  • תת הדומיינים שלך ב- Firebase:
    PROJECT_ID .web.app/ ו PROJECT_ID .firebaseapp.com/

  • כל המחוברים תחומים המנהג :
    CUSTOM_DOMAIN /

בקר בדף תצורת האירוח עבור פרטים נוספים על כללי שכתוב . ניתן גם ללמוד על סדר העדיפות של תגובות עבור תצורות אירוח שונות.

מבחן מקומי

במהלך הפיתוח, תוכל להריץ ולבדוק את תמונת המכולה שלך באופן מקומי. לקבלת הוראות מפורטות, בקר תיעוד הפעלת הענן .

הצעדים הבאים