Udostępniaj dynamiczną zawartość i hostuj mikroserwisy za pomocą Cloud Run

Połącz Cloud Run z Firebase Hosting, aby generować i udostępniać treści dynamiczne lub tworzyć interfejsy API REST jako mikrousługi.

Za pomocą Cloud Run możesz wdrożyć aplikację spakowaną w obrazie kontenera. Następnie, korzystając z Hostingu Firebase, możesz kierować żądania HTTPS w celu uruchomienia aplikacji kontenerowej.

  • Cloud Run obsługuje kilka języków (w tym Go, Node.js, Python i Java), co zapewnia elastyczność w korzystaniu z wybranego języka programowania i platformy.
  • Cloud Run automatycznie i poziomo skaluje obraz kontenera, aby obsłużyć otrzymane żądania, a następnie skaluje w dół, gdy zapotrzebowanie spada.
  • Płacisz tylko za procesor, pamięć i sieć zużyte podczas obsługi żądań.

Na przykład przypadki użycia i przykłady dotyczące Cloud Run zintegrowanego z Firebase Hosting znajdziesz w naszym przeglądzie rozwiązań bezserwerowych .


W tym przewodniku dowiesz się, jak:

  1. Napisz prostą aplikację Hello World
  2. Konteneryzuj aplikację i prześlij ją do Container Registry
  3. Wdróż obraz kontenera w Cloud Run
  4. Kieruj żądania hostingu do swojej aplikacji kontenerowej

Pamiętaj, że aby poprawić wydajność udostępniania treści dynamicznych, możesz opcjonalnie dostroić ustawienia pamięci podręcznej .

Zanim zaczniesz

Przed użyciem Cloud Run musisz wykonać kilka początkowych zadań, w tym skonfigurować konto rozliczeniowe Cloud, włączyć interfejs Cloud Run API i zainstalować narzędzie wiersza poleceń gcloud .

Skonfiguruj rozliczenia dla swojego projektu

Cloud Run oferuje bezpłatny limit użytkowania , ale aby móc korzystać z Cloud Run lub go wypróbować, nadal musisz mieć konto rozliczeniowe Cloud powiązane z projektem Firebase.

Włącz interfejs API i zainstaluj pakiet SDK

  1. Włącz interfejs Cloud Run API w konsoli Google API:

    1. Otwórz stronę Cloud Run API w konsoli Google API.

    2. Po wyświetleniu monitu wybierz projekt Firebase.

    3. Kliknij Włącz na stronie Cloud Run API.

  2. Zainstaluj i zainicjuj pakiet Cloud SDK.

  3. Sprawdź, czy narzędzie gcloud jest skonfigurowane dla prawidłowego projektu:

    gcloud config list

Krok 1 : Napisz przykładową aplikację

Pamiętaj, że oprócz języków pokazanych w poniższym przykładzie Cloud Run obsługuje wiele innych języków .

Iść

  1. Utwórz nowy katalog o nazwie helloworld-go , a następnie zmień na niego katalog:

    mkdir helloworld-go
    cd helloworld-go

  2. Utwórz nowy plik o nazwie helloworld.go , a następnie dodaj następujący kod:

    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

    Ten kod tworzy podstawowy serwer WWW, który nasłuchuje na porcie zdefiniowanym przez zmienną środowiskową PORT .

Twoja aplikacja jest ukończona i gotowa do konteneryzacji i przesłania do Container Registry.

Node.js

  1. Utwórz nowy katalog o nazwie helloworld-nodejs , a następnie zmień na niego katalog:

    mkdir helloworld-nodejs
    cd helloworld-nodejs

  2. Utwórz plik package.json z następującą zawartością:

    {
  "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. Utwórz nowy plik o nazwie index.js , a następnie dodaj następujący kod:

    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

    Ten kod tworzy podstawowy serwer WWW, który nasłuchuje na porcie zdefiniowanym przez zmienną środowiskową PORT .

Twoja aplikacja jest ukończona i gotowa do konteneryzacji i przesłania do Container Registry.

Pyton

  1. Utwórz nowy katalog o nazwie helloworld-python , a następnie zmień na niego katalog:

    mkdir helloworld-python
    cd helloworld-python

  2. Utwórz nowy plik o nazwie app.py , a następnie dodaj następujący kod:

    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

    Ten kod tworzy podstawowy serwer WWW, który nasłuchuje na porcie zdefiniowanym przez zmienną środowiskową PORT .

Twoja aplikacja jest ukończona i gotowa do konteneryzacji i przesłania do Container Registry.

Jawa

  1. Zainstaluj Java SE 8 lub nowszą wersję JDK i CURL .

    Pamiętaj, że musimy to zrobić tylko po to, aby w następnym kroku utworzyć nowy projekt internetowy. Plik Dockerfile, opisany później, załaduje wszystkie zależności do kontenera.

  2. W konsoli utwórz nowy pusty projekt internetowy za pomocą cURL, a następnie rozpakuj polecenia:

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

    Spowoduje to utworzenie projektu SpringBoot.

  3. Zaktualizuj klasę SpringBootApplication w pliku src/main/java/com/example/helloworld/HelloworldApplication.java dodając @RestController do obsługi mapowania / , a także dodaj pole @Value , aby udostępnić zmienną środowiskową 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

    Ten kod tworzy podstawowy serwer WWW, który nasłuchuje na porcie zdefiniowanym przez zmienną środowiskową PORT .

Twoja aplikacja jest ukończona i gotowa do konteneryzacji i przesłania do Container Registry.

Krok 2 : Konteneryzuj aplikację i prześlij ją do Container Registry

  1. Konteneryzuj przykładową aplikację, tworząc nowy plik o nazwie Dockerfile w tym samym katalogu, co pliki źródłowe. Skopiuj następującą zawartość do swojego pliku.

    Iść

    # 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

    Pyton

    # 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

    Jawa

    # 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. Zbuduj obraz kontenera za pomocą Cloud Build, uruchamiając następujące polecenie z katalogu zawierającego plik Dockerfile:

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

    Po pomyślnym zakończeniu zostanie wyświetlony komunikat SUKCES zawierający nazwę obrazu
    ( gcr.io/ PROJECT_ID /helloworld ).

Obraz kontenera jest teraz przechowywany w Container Registry i w razie potrzeby można go ponownie wykorzystać.

Pamiętaj, że zamiast Cloud Build możesz użyć lokalnie zainstalowanej wersji Dockera, aby lokalnie zbudować kontener .

Krok 3 : Wdróż obraz kontenera w Cloud Run

  1. Wdróż za pomocą następującego polecenia:

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

  2. Gdy pojawi się monit:

Aby uzyskać najlepszą wydajność, połącz usługę Cloud Run z Hostingiem, korzystając z następujących regionów:

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

Przepisywanie do Cloud Run z Hostingu jest obsługiwane w następujących regionach:

  • 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. Poczekaj kilka chwil na zakończenie wdrażania. Jeśli operacja się powiedzie, w wierszu poleceń zostanie wyświetlony adres URL usługi. Na przykład https://helloworld- RANDOM_HASH -us-central1.a.run.app

  2. Odwiedź wdrożony kontener, otwierając adres URL usługi w przeglądarce internetowej.

Następny krok przeprowadzi Cię przez proces uzyskiwania dostępu do tej skonteneryzowanej aplikacji z adresu URL hostingu Firebase, aby mogła ona generować dynamiczną zawartość dla Twojej witryny hostowanej przez Firebase.

Krok 4: Kieruj żądania hostingu do swojej aplikacji kontenerowej

Dzięki regułom przepisywania możesz kierować żądania pasujące do określonych wzorców do jednego miejsca docelowego.

Poniższy przykład pokazuje, jak skierować wszystkie żądania ze strony /helloworld w witrynie hostingowej, aby wyzwolić uruchomienie i uruchomienie instancji kontenera helloworld .

  1. Upewnij się, że:

    Szczegółowe instrukcje dotyczące instalowania interfejsu CLI i inicjowania hostingu można znaleźć w przewodniku wprowadzającym dotyczącym hostingu .

  2. Otwórz plik firebase.json .

  3. Dodaj następującą konfigurację rewrite w sekcji 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. Wdróż konfigurację hostingu w swojej witrynie, uruchamiając następujące polecenie w katalogu głównym katalogu projektu:

    firebase deploy --only hosting

Twój kontener jest teraz dostępny pod następującymi adresami URL:

  • Twoje subdomeny Firebase:
    PROJECT_ID .web.app/ i PROJECT_ID .firebaseapp.com/

  • Wszelkie połączone domeny niestandardowe :
    CUSTOM_DOMAIN /

Odwiedź stronę konfiguracji Hostingu, aby uzyskać więcej szczegółów na temat reguł przepisywania . Możesz także dowiedzieć się o kolejności priorytetów odpowiedzi dla różnych konfiguracji Hostingu.

Testuj lokalnie

Podczas programowania możesz uruchamiać i testować obraz kontenera lokalnie. Szczegółowe instrukcje znajdziesz w dokumentacji Cloud Run .

Następne kroki