عرض المحتوى الديناميكي واستضافة الخدمات المصغَّرة باستخدام Cloud Run

يمكنك إقران Cloud Run مع Firebase Hosting لإنشاء المحتوى الديناميكي وعرضه أو إنشاء واجهات برمجة تطبيقات REST كخدمات مصغّرة.

باستخدام Cloud Run، يمكنك نشر تطبيق مجمّع في صورة حاوية. بعد ذلك، باستخدام Firebase Hosting، يمكنك توجيه طلبات HTTPS لتشغيل تطبيقك الذي تم وضعه في حاوية.

للاطّلاع على حالات الاستخدام والنماذج الخاصة بدمج 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 أو تجربته.

تفعيل واجهة برمجة التطبيقات وتثبيت حزمة تطوير البرامج (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.

اكتمل تطبيقك وأصبح جاهزًا لوضعه في حاوية وتحميله إلى 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"
  }
}

    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.

اكتمل تطبيقك وأصبح جاهزًا لوضعه في حاوية وتحميله إلى 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)))

    app.py

    ينشئ هذا الرمز البرمجي خادم ويب أساسيًا يستمع إلى المنفذ الذي يحدّده متغيّر البيئة PORT.

اكتمل تطبيقك وأصبح جاهزًا لوضعه في حاوية وتحميله إلى Artifact 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.

اكتمل تطبيقك وأصبح جاهزًا لوضعه في حاوية وتحميله إلى 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"]

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

تم الآن تخزين صورة الحاوية في Artifact Registry ويمكن إعادة استخدامها إذا أردت ذلك.

يُرجى العِلم أنّه بدلاً من Cloud Build، يمكنك استخدام إصدار مثبَّت محليًا من Docker لـ إنشاء الحاوية محليًا.

الخطوة 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 للخدمة في متصفّح ويب.

Cloud Run

توضّح لك الخطوة التالية كيفية الوصول إلى هذا التطبيق الذي تم وضعه في حاوية من عنوان Firebase Hosting URL حتى يتمكّن من إنشاء محتوى ديناميكي لموقعك المستضاف على Firebase.

الخطوة 4: توجيه طلبات الاستضافة إلى تطبيقك الذي تم وضعه في حاوية

باستخدام قواعد إعادة الكتابة، يمكنك توجيه الطلبات التي تطابق أنماطًا معيّنة إلى وجهة واحدة.

يوضّح المثال التالي كيفية توجيه جميع الطلبات من الصفحة /helloworld على موقعك Hosting لتشغيل مثيل الحاوية الخاص بك helloworld وبدء تشغيله.

  1. تأكَّد مما يلي:

    • لديك أحدث إصدار من CLIFirebase.

    • لقد قمت بتهيئة Firebase Hosting.

    للحصول على تعليمات مفصّلة حول تثبيت واجهة سطر الأوامر وبدء استخدام 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. انشر إعدادات الاستضافة على موقعك الإلكتروني عن طريق تنفيذ الأمر التالي من جذر دليل مشروعك:

    firebase deploy --only hosting

يمكن الآن الوصول إلى الحاوية من خلال عناوين URL التالية:

  • النطاقات الفرعية على Firebase:
    PROJECT_ID.web.app/ و PROJECT_ID.firebaseapp.com/

  • أي نطاقات مخصّصة مرتبطة:
    CUSTOM_DOMAIN/

انتقِل إلى صفحة إعدادات Hosting لمزيد من التفاصيل حول قواعد إعادة الكتابة. يمكنك أيضًا التعرّف على ترتيب أولوية الردود لإعدادات Hosting مختلفة.

الاختبار محليًا

أثناء التطوير، يمكنك تشغيل صورة الحاوية واختبارها محليًا. للحصول على تعليمات مفصّلة، يُرجى الانتقال إلى Cloud Run مستندات.

الخطوات التالية