क्लाउड रन के साथ गतिशील सामग्री परोसें और माइक्रोसर्विसेज होस्ट करें

अपनी गतिशील सामग्री तैयार करने और परोसने या माइक्रोसर्विसेज के रूप में REST API बनाने के लिए क्लाउड रन को फायरबेस होस्टिंग के साथ जोड़ें।

क्लाउड रन का उपयोग करके, आप एक कंटेनर छवि में पैक किए गए एप्लिकेशन को तैनात कर सकते हैं। फिर, फायरबेस होस्टिंग का उपयोग करके, आप अपने कंटेनरीकृत ऐप को ट्रिगर करने के लिए HTTPS अनुरोधों को निर्देशित कर सकते हैं।

उदाहरण के लिए फायरबेस होस्टिंग के साथ एकीकृत क्लाउड रन के लिए उपयोग के मामलों और नमूनों के लिए, हमारे सर्वर रहित अवलोकन पर जाएं।


यह मार्गदर्शिका आपको दिखाती है कि कैसे करें:

  1. एक सरल हैलो वर्ल्ड एप्लिकेशन लिखें
  2. किसी ऐप को कंटेनराइज़ करें और उसे कंटेनर रजिस्ट्री पर अपलोड करें
  3. कंटेनर छवि को क्लाउड रन पर तैनात करें
  4. आपके कंटेनरीकृत ऐप पर सीधे होस्टिंग अनुरोध

ध्यान दें कि गतिशील सामग्री परोसने के प्रदर्शन को बेहतर बनाने के लिए, आप वैकल्पिक रूप से अपनी कैश सेटिंग्स को ट्यून कर सकते हैं।

शुरू करने से पहले

क्लाउड रन का उपयोग करने से पहले, आपको कुछ प्रारंभिक कार्य पूरे करने होंगे, जिसमें क्लाउड बिलिंग खाता स्थापित करना, क्लाउड रन एपीआई को सक्षम करना और gcloud कमांड लाइन टूल इंस्टॉल करना शामिल है।

अपने प्रोजेक्ट के लिए बिलिंग सेट करें

क्लाउड रन मुफ़्त उपयोग कोटा प्रदान करता है, लेकिन क्लाउड रन का उपयोग करने या आज़माने के लिए आपके पास अभी भी आपके फायरबेस प्रोजेक्ट से जुड़ा एक क्लाउड बिलिंग खाता होना चाहिए।

एपीआई सक्षम करें और एसडीके इंस्टॉल करें

  1. Google API कंसोल में क्लाउड रन API सक्षम करें:

    1. Google API कंसोल में क्लाउड रन API पृष्ठ खोलें।

    2. संकेत मिलने पर, अपना फायरबेस प्रोजेक्ट चुनें।

    3. क्लाउड रन एपीआई पेज पर सक्षम करें पर क्लिक करें।

  2. क्लाउड एसडीके स्थापित करें और प्रारंभ करें ।

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

    helloworld.go

    यह कोड एक बुनियादी वेब सर्वर बनाता है जो PORT पर्यावरण चर द्वारा परिभाषित पोर्ट पर सुनता है।

आपका ऐप तैयार है और कंटेनरीकृत होने और कंटेनर रजिस्ट्री पर अपलोड करने के लिए तैयार है।

नोड.जे.एस

  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.18.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 पर्यावरण चर द्वारा परिभाषित पोर्ट पर सुनता है।

आपका ऐप तैयार है और कंटेनरीकृत होने और कंटेनर रजिस्ट्री पर अपलोड करने के लिए तैयार है।

अजगर

  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 पर्यावरण चर द्वारा परिभाषित पोर्ट पर सुनता है।

आपका ऐप तैयार है और कंटेनरीकृत होने और कंटेनर रजिस्ट्री पर अपलोड करने के लिए तैयार है।

जावा

  1. Java SE 8 या बाद का JDK और CURL स्थापित करें।

    ध्यान दें कि हमें केवल अगले चरण में नया वेब प्रोजेक्ट बनाने के लिए ऐसा करने की आवश्यकता है। डॉकरफ़ाइल, जिसका वर्णन बाद में किया गया है, सभी निर्भरताओं को कंटेनर में लोड करेगा।

  2. कंसोल से, cURL का उपयोग करके एक नया खाली वेब प्रोजेक्ट बनाएं और फिर कमांड को अनज़िप करें:

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

    यह एक स्प्रिंगबूट प्रोजेक्ट बनाता है।

  3. / मैपिंग को संभालने के लिए @RestController जोड़कर src/main/java/com/example/helloworld/HelloworldApplication.java में SpringBootApplication क्लास को अपडेट करें और TARGET पर्यावरण चर प्रदान करने के लिए एक @Value फ़ील्ड भी जोड़ें:

    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 पर्यावरण चर द्वारा परिभाषित पोर्ट पर सुनता है।

आपका ऐप तैयार है और कंटेनरीकृत होने और कंटेनर रजिस्ट्री पर अपलोड करने के लिए तैयार है।

चरण 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: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

    नोड.जे.एस

    # 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

    अजगर

    # 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

    जावा

    # 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. अपनी Dockerfile वाली निर्देशिका से निम्नलिखित कमांड चलाकर क्लाउड बिल्ड का उपयोग करके अपनी कंटेनर छवि बनाएं:

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

    सफलता मिलने पर, आपको छवि नाम वाला एक SUCCESS संदेश दिखाई देगा
    ( gcr.io/ PROJECT_ID /helloworld )।

कंटेनर छवि अब कंटेनर रजिस्ट्री में संग्रहीत है और यदि वांछित हो तो इसका पुन: उपयोग किया जा सकता है।

ध्यान दें कि, क्लाउड बिल्ड के बजाय, आप अपने कंटेनर को स्थानीय रूप से बनाने के लिए डॉकर के स्थानीय रूप से स्थापित संस्करण का उपयोग कर सकते हैं।

चरण 3 : कंटेनर छवि को क्लाउड रन पर तैनात करें

  1. निम्नलिखित आदेश का उपयोग करके तैनात करें:

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

  2. जब नौबत आई:

सर्वोत्तम प्रदर्शन के लिए, निम्नलिखित क्षेत्रों का उपयोग करके अपनी क्लाउड रन सेवा को होस्टिंग के साथ संयोजित करें:

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

होस्टिंग से क्लाउड रन पर पुनर्लेखन निम्नलिखित क्षेत्रों में समर्थित है:

  • 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 खोलकर अपने तैनात कंटेनर पर जाएँ।

अगला चरण आपको फायरबेस होस्टिंग यूआरएल से इस कंटेनरीकृत ऐप तक पहुंचने का तरीका बताता है ताकि यह आपकी फायरबेस-होस्टेड साइट के लिए गतिशील सामग्री उत्पन्न कर सके।

चरण 4: आपके कंटेनरीकृत ऐप पर सीधे होस्टिंग अनुरोध

पुनर्लेखन नियमों के साथ, आप विशिष्ट पैटर्न से मेल खाने वाले अनुरोधों को एक ही गंतव्य पर निर्देशित कर सकते हैं।

निम्नलिखित उदाहरण दिखाता है कि आपके helloworld कंटेनर इंस्टेंस के स्टार्टअप और रनिंग को ट्रिगर करने के लिए आपकी होस्टिंग साइट पर पेज /helloworld से सभी अनुरोधों को कैसे निर्देशित किया जाए।

  1. सुनिश्चित करें कि:

    सीएलआई स्थापित करने और होस्टिंग प्रारंभ करने के बारे में विस्तृत निर्देशों के लिए, होस्टिंग के लिए प्रारंभ करें मार्गदर्शिका देखें।

  2. अपनी firebase.json फ़ाइल खोलें।

  3. hosting अनुभाग के अंतर्गत निम्नलिखित rewrite कॉन्फ़िगरेशन जोड़ें:

    "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

आपका कंटेनर अब निम्नलिखित यूआरएल के माध्यम से पहुंच योग्य है:

  • आपके फायरबेस उपडोमेन:
    PROJECT_ID .web.app/ और PROJECT_ID .firebaseapp.com/

  • कोई भी कनेक्टेड कस्टम डोमेन :
    CUSTOM_DOMAIN /

पुनर्लेखन नियमों के बारे में अधिक जानकारी के लिए होस्टिंग कॉन्फ़िगरेशन पृष्ठ पर जाएँ। आप विभिन्न होस्टिंग कॉन्फ़िगरेशन के लिए प्रतिक्रियाओं के प्राथमिकता क्रम के बारे में भी जान सकते हैं।

स्थानीय स्तर पर परीक्षण करें

विकास के दौरान, आप अपनी कंटेनर छवि को स्थानीय स्तर पर चला और परीक्षण कर सकते हैं। विस्तृत निर्देशों के लिए, क्लाउड रन दस्तावेज़ पर जाएँ।

अगले कदम