แสดงเนื้อหาแบบไดนามิกและโฮสต์ Microservice ด้วย Cloud Run

จับคู่ Cloud Run กับโฮสติ้งของ Firebase เพื่อสร้างและให้บริการ เนื้อหาแบบไดนามิก หรือสร้าง REST API เป็น Microservice

เมื่อใช้ Cloud Run คุณจะทำสิ่งต่อไปนี้ได้ ทำให้แอปพลิเคชันที่อยู่ในอิมเมจคอนเทนเนอร์ใช้งานได้ จากนั้นใช้ โฮสติ้งของ Firebase คุณสามารถร้องขอ HTTPS เพื่อทริกเกอร์ ที่สร้างโดยใช้คอนเทนเนอร์

  • Cloud Run รองรับ หลายภาษา (ได้แก่ Go, Node.js, Python และ Java) คุณจึงมีความยืดหยุ่นในการใช้งาน ภาษาโปรแกรมและกรอบงานที่คุณเลือก
  • การเรียกใช้ระบบคลาวด์ ปรับสเกลอัตโนมัติและแนวนอน อิมเมจคอนเทนเนอร์เพื่อจัดการคำขอที่ได้รับ จากนั้นจึงปรับขนาดลงเมื่อ ความต้องการลดลง
  • คุณชำระเงินสำหรับ CPU เท่านั้น หน่วยความจำและเครือข่ายที่ใช้ระหว่างการจัดการคำขอ

ตัวอย่าง Use Case และตัวอย่างสำหรับ Cloud Run ที่ผสานรวมกับ โฮสติ้งของ Firebase โปรดไปที่ ภาพรวมแบบ Serverless


คู่มือนี้แสดงวิธีการต่อไปนี้

  1. เขียนแอปพลิเคชัน Hello World แบบเรียบง่าย
  2. สร้างคอนเทนเนอร์และอัปโหลดไปยัง Container Registry
  3. ทำให้อิมเมจคอนเทนเนอร์ใช้งานได้กับ Cloud Run
  4. คำขอโฮสติ้งไปยังแอปที่สร้างโดยใช้คอนเทนเนอร์โดยตรง

โปรดทราบว่า เพื่อปรับปรุงประสิทธิภาพการแสดงเนื้อหาแบบไดนามิก คุณสามารถ (ไม่บังคับ) ปรับการตั้งค่าแคช

ก่อนเริ่มต้น

ก่อนใช้ Cloud Run คุณต้องทำงานเริ่มต้นบางอย่างให้เสร็จ ซึ่งรวมถึงการตั้งค่าบัญชีสำหรับการเรียกเก็บเงินใน Cloud, การเปิดใช้ Cloud Run API และติดตั้งเครื่องมือบรรทัดคำสั่ง gcloud

ตั้งค่าการเรียกเก็บเงินสำหรับโปรเจ็กต์

Cloud Run มอบโควต้าการใช้งานฟรี แต่คุณยังต้องมี บัญชีสำหรับการเรียกเก็บเงินใน Cloud ที่เชื่อมโยงกับโปรเจ็กต์ Firebase เพื่อใช้หรือลองใช้ Cloud Run

เปิดใช้ API และติดตั้ง SDK

  1. เปิดใช้ Cloud Run API ในคอนโซล Google APIs ดังนี้

    1. เปิด หน้า Cloud Run API ในคอนโซล Google APIs

    2. เมื่อมีข้อความแจ้ง ให้เลือกโปรเจ็กต์ Firebase ของคุณ

    3. คลิกเปิดใช้ในหน้า Cloud Run API

  2. ติดตั้งและเริ่มต้น Cloud SDK

  3. ตรวจสอบว่าได้กำหนดค่าเครื่องมือ gcloud สำหรับโปรเจ็กต์ที่ถูกต้องแล้ว ดังนี้

    gcloud config list

ขั้นตอนที่ 1: เขียนแอปพลิเคชันตัวอย่าง

โปรดทราบว่า Cloud Run รองรับ ภาษาอื่นๆ อีกมากมาย นอกเหนือจากภาษาที่แสดงในตัวอย่างต่อไปนี้

Go

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

    helloworld.go

    โค้ดนี้จะสร้างเว็บเซิร์ฟเวอร์พื้นฐานที่รับข้อมูลบนพอร์ตที่กำหนดโดย ตัวแปรสภาพแวดล้อม PORT

แอปของคุณเสร็จแล้วและพร้อมที่จะสร้างด้วยคอนเทนเนอร์และอัปโหลดไปยัง Container Registry

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.19.2"
  }
}

    package.json

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

    index.js

    โค้ดนี้จะสร้างเว็บเซิร์ฟเวอร์พื้นฐานที่รับข้อมูลบนพอร์ตที่กำหนดโดย ตัวแปรสภาพแวดล้อม PORT

แอปของคุณเสร็จแล้วและพร้อมที่จะสร้างด้วยคอนเทนเนอร์และอัปโหลดไปยัง Container Registry

Python

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

    app.py

    โค้ดนี้จะสร้างเว็บเซิร์ฟเวอร์พื้นฐานที่รับข้อมูลบนพอร์ตที่กำหนดโดย ตัวแปรสภาพแวดล้อม PORT

แอปของคุณเสร็จแล้วและพร้อมที่จะสร้างด้วยคอนเทนเนอร์และอัปโหลดไปยัง Container Registry

Java

  1. ติดตั้ง Java SE 8 ขึ้นไป 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);
  }
}

    HelloworldApplication.java

    โค้ดนี้จะสร้างเว็บเซิร์ฟเวอร์พื้นฐานที่รับข้อมูลบนพอร์ตที่กำหนดโดย ตัวแปรสภาพแวดล้อม PORT

แอปของคุณเสร็จแล้วและพร้อมที่จะสร้างด้วยคอนเทนเนอร์และอัปโหลดไปยัง Container Registry

ขั้นตอนที่ 2: สร้างคอนเทนเนอร์แอปและอัปโหลดไปยัง Container Registry

  1. สร้างคอนเทนเนอร์แอปตัวอย่างโดยการสร้างไฟล์ใหม่ชื่อ Dockerfile ใน ไดเรกทอรีเดียวกับไฟล์ต้นฉบับ คัดลอกเนื้อหาต่อไปนี้ลงใน

    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. สร้างอิมเมจคอนเทนเนอร์โดยใช้ Cloud Build โดยการเรียกใช้อิมเมจต่อไปนี้ จากไดเรกทอรีที่มี Dockerfile:

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

    เมื่อทำสำเร็จแล้ว คุณจะเห็นข้อความ "สำเร็จ" ที่มีชื่อรูปภาพ
    (gcr.io/PROJECT_ID/helloworld)

ตอนนี้ระบบได้จัดเก็บอิมเมจคอนเทนเนอร์ไว้ใน Container Registry แล้ว และสามารถนำอิมเมจคอนเทนเนอร์มาใช้ซ้ำได้หาก ที่ต้องการ

โปรดทราบว่าคุณใช้เวอร์ชันที่ติดตั้งในเครื่องแทน Cloud Build ได้ จาก Docker ไปยัง สร้างคอนเทนเนอร์ในเครื่อง

ขั้นตอนที่ 3: ทำให้อิมเมจคอนเทนเนอร์ใช้งานได้กับ Cloud Run

  1. ทำให้ใช้งานได้โดยใช้คำสั่งต่อไปนี้

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

  2. เมื่อระบบแจ้ง ให้ทำดังนี้

เพื่อประสิทธิภาพที่ดีที่สุด ให้จัดสรรบริการ Cloud Run กับโฮสติ้งโดยใช้ภูมิภาคต่อไปนี้

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

ระบบรองรับการเขียนใหม่จากโฮสติ้งไปยัง Cloud Run ใน ภูมิภาคต่อไปนี้:

  • 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. โปรดรอสักครู่เพื่อให้การติดตั้งใช้งานเสร็จสมบูรณ์ เมื่อทำสำเร็จ บรรทัดคำสั่ง แสดง URL ของบริการ ดังตัวอย่างต่อไปนี้ https://helloworld-RANDOM_HASH-us-central1.a.run.app

  2. ไปที่คอนเทนเนอร์ที่ทำให้ใช้งานได้แล้วโดยเปิด URL ของบริการในเว็บเบราว์เซอร์

ขั้นตอนถัดไปจะแนะนำวิธีเข้าถึงแอปที่สร้างโดยใช้คอนเทนเนอร์นี้จาก 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)
      "pinTag": true              // optional (see note below)
    }
  } ]
}

  4. ทำให้การกำหนดค่าโฮสติ้งใช้งานได้ในเว็บไซต์โดยการเรียกใช้การกำหนดค่าต่อไปนี้ จากรูทของไดเรกทอรีโปรเจ็กต์ของคุณ:

    firebase deploy --only hosting

ตอนนี้คอนเทนเนอร์ของคุณสามารถเข้าถึงได้ผ่านทาง URL ต่อไปนี้แล้ว

ไปที่หน้าการกำหนดค่าโฮสติ้งสำหรับ รายละเอียดเพิ่มเติมเกี่ยวกับกฎการเขียนใหม่ คุณสามารถ รวมถึงเรียนรู้เกี่ยวกับ ลำดับความสำคัญของการตอบกลับ สำหรับการกำหนดค่าโฮสติ้งที่หลากหลาย

ทดสอบในเครื่อง

ระหว่างการพัฒนา คุณจะเรียกใช้และทดสอบอิมเมจคอนเทนเนอร์ในเครื่องได้ สำหรับ คำแนะนำโดยละเอียด โปรดไปที่ เอกสารประกอบเกี่ยวกับ Cloud Run

ขั้นตอนถัดไป