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

จับคู่ Cloud Run กับ Firebase Hosting เพื่อสร้างและแสดงเนื้อหาแบบไดนามิก หรือสร้าง REST API เป็นไมโครเซอร์วิส

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

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

ดูตัวอย่างกรณีการใช้งานและตัวอย่างการผสานรวมCloud Run กับ Firebase Hostingได้ที่ ภาพรวมแบบไม่มีเซิร์ฟเวอร์


คู่มือนี้จะแสดงวิธีทำสิ่งต่อไปนี้

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

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

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

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

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

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

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

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

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

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

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

แอปของคุณเสร็จสมบูรณ์แล้วและพร้อมที่จะสร้างคอนเทนเนอร์และอัปโหลดไปยัง Artifact 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.22.1"
  }
}

  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

แอปของคุณเสร็จสมบูรณ์แล้วและพร้อมที่จะสร้างคอนเทนเนอร์และอัปโหลดไปยัง Artifact 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)))

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

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

Java

  1. ติดตั้ง Java SE 8 หรือ JDK เวอร์ชันที่ใหม่กว่า และ CURL.

    โปรดทราบว่าเราต้องทำเช่นนี้เพื่อสร้างโปรเจ็กต์เว็บใหม่ในขั้นตอนถัดไปเท่านั้น Dockerfile ซึ่งจะอธิบายในภายหลังจะโหลดการอ้างอิงทั้งหมดลงในคอนเทนเนอร์

  2. สร้างโปรเจ็กต์เว็บใหม่ที่ว่างเปล่าจากคอนโซลโดยใช้คำสั่ง cURL จากนั้นใช้คำสั่ง unzip

    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

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

ขั้นตอนที่ 2: สร้างคอนเทนเนอร์ของแอปและอัปโหลดไปยัง Artifact 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

# Copy local code to the container image.
COPY . ./

# Install dependencies and tidy up the go.mod and go.sum files.
RUN go mod tidy

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

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

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

    เมื่อสำเร็จ คุณจะเห็นข้อความ SUCCESS ที่มีชื่ออิมเมจ
    (gcr.io/PROJECT_ID/helloworld)

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

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

ขั้นตอนที่ 3: ทำให้ใช้งานได้กับ Cloud Run

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

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

  2. เมื่อได้รับข้อความแจ้ง ให้ทำดังนี้

  3. รอสักครู่เพื่อให้การทำให้ใช้งานได้เสร็จสมบูรณ์ เมื่อสำเร็จ บรรทัดคำสั่งจะแสดง URL ของบริการ เช่น: https://helloworld-RANDOM_HASH-us-central1.a.run.app

  4. เปิด URL ของบริการในเว็บเบราว์เซอร์เพื่อเข้าชมคอนเทนเนอร์ที่ทำให้ใช้งานได้

ขั้นตอนถัดไปจะแนะนำวิธีเข้าถึงแอปที่อยู่ในคอนเทนเนอร์นี้ จาก Firebase Hosting URL เพื่อให้แอปสร้างเนื้อหาแบบไดนามิกสำหรับ เว็บไซต์ที่โฮสต์ใน Firebase ได้

ขั้นตอนที่ 4: ส่งคำขอ Hosting ไปยังแอปที่อยู่ในคอนเทนเนอร์

กฎการเขียนซ้ำช่วยให้คุณส่งคำขอ ที่ตรงกับรูปแบบที่เฉพาะเจาะจงไปยังปลายทางเดียวได้

ตัวอย่างต่อไปนี้แสดงวิธีส่งคำขอทั้งหมดจากหน้า /helloworld ในเว็บไซต์ Hosting ไปทริกเกอร์การเริ่มต้นและการทำงานของ อินสแตนซ์คอนเทนเนอร์ helloworld

  1. โปรดตรวจสอบดังนี้

    ดูวิธีการโดยละเอียดเกี่ยวกับการติดตั้ง CLI และการเริ่มต้น Hosting ได้ที่ คู่มือเริ่มต้นใช้งานสำหรับ Hosting

  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. ทำให้การกำหนดค่า Hosting ใช้งานได้กับเว็บไซต์โดยเรียกใช้คำสั่งต่อไปนี้จากไดเรกทอรีรากของโปรเจ็กต์

    firebase deploy --only hosting

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

ดูรายละเอียดเพิ่มเติมเกี่ยวกับกฎการเขียนซ้ำได้ที่หน้าการกำหนดค่า Hosting สำหรับ นอกจากนี้ คุณยังดูข้อมูลเกี่ยวกับ ลำดับความสำคัญของการตอบกลับ สำหรับการกำหนดค่า Hosting ต่างๆ ได้ด้วย

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

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

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