Menayangkan konten dinamis dan menghosting microservice dengan Cloud Run

Pasangkan Cloud Run dengan Firebase Hosting untuk membuat dan menayangkan konten dinamis Anda atau membangun REST API sebagai microservice.

Dengan menggunakan Cloud Run, Anda dapat men-deploy aplikasi yang dikemas dalam image container. Selanjutnya, dengan menggunakan Firebase Hosting, Anda dapat mengarahkan permintaan HTTPS untuk memicu aplikasi dalam container.

  • Cloud Run mendukung sejumlah bahasa (termasuk Go, Node.js, Python, dan Java), sehingga Anda leluasa menggunakan bahasa pemrograman dan framework pilihan Anda.
  • Cloud Run menskalakan image container secara otomatis dan horizontal untuk menangani permintaan yang diterima, lalu memperkecil skala saat permintaan berkurang.
  • Anda hanya membayar untuk CPU, memori, dan jaringan yang terpakai selama penanganan permintaan.

Untuk melihat contoh kasus penggunaan dan contoh integrasi Cloud Run dengan Firebase Hosting, lihat ringkasan serverless kami.


Panduan ini menunjukkan cara:

  1. Menulis aplikasi Halo Dunia sederhana
  2. Memasukkan aplikasi ke dalam container dan menguploadnya ke Container Registry
  3. Men-deploy image container ke Cloud Run
  4. Mengarahkan permintaan Hosting ke aplikasi dalam container

Perlu diingat bahwa untuk meningkatkan performa penayangan konten dinamis, Anda juga dapat menyesuaikan setelan cache (opsional).

Sebelum memulai

Sebelum menggunakan Cloud Run, selesaikan beberapa tugas awal, termasuk menyiapkan akun Penagihan Cloud, mengaktifkan Cloud Run API, dan menginstal alat command line gcloud.

Menyiapkan penagihan untuk project Anda

Cloud Run menawarkan kuota penggunaan gratis, tetapi Anda tetap harus memiliki akun Penagihan Cloud yang dikaitkan dengan project Firebase Anda untuk menggunakan atau mencoba Cloud Run.

Mengaktifkan API dan menginstal SDK

  1. Aktifkan Cloud Run API di konsol API Google:

    1. Buka halaman Cloud Run API di konsol API Google.

    2. Saat diminta, pilih project Firebase Anda.

    3. Klik Enable pada halaman Cloud Run API.

  2. Instal dan lakukan inisialisasi Cloud SDK.

  3. Pastikan bahwa alat gcloud dikonfigurasikan untuk project yang tepat:

    gcloud config list

Langkah 1: Tulis aplikasi contoh

Ingat bahwa Cloud Run mendukung banyak bahasa lain selain yang ditampilkan dalam contoh berikut.

Go

  1. Buat direktori baru bernama helloworld-go, lalu pindahlah ke direktori tersebut:

    mkdir helloworld-go
    cd helloworld-go

  2. Buat file baru bernama helloworld.go, lalu tambahkan kode berikut:

    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

    Kode ini menghasilkan server web dasar yang memantau port yang ditentukan oleh variabel lingkungan PORT.

Aplikasi Anda sudah jadi dan siap dimasukkan ke dalam container dan diupload ke Container Registry.

Node.js

  1. Buat direktori baru bernama helloworld-nodejs, lalu pindahlah ke direktori tersebut:

    mkdir helloworld-nodejs
    cd helloworld-nodejs

  2. Buat file package.json dengan konten berikut:

    {
  "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. Buat file baru bernama index.js, lalu tambahkan kode berikut:

    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

    Kode ini menghasilkan server web dasar yang memantau port yang ditentukan oleh variabel lingkungan PORT.

Aplikasi Anda sudah jadi dan siap dimasukkan ke dalam container dan diupload ke Container Registry.

Python

  1. Buat direktori baru bernama helloworld-python, lalu pindahlah ke direktori tersebut:

    mkdir helloworld-python
    cd helloworld-python

  2. Buat file baru bernama app.py, lalu tambahkan kode berikut:

    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

    Kode ini menghasilkan server web dasar yang memantau port yang ditentukan oleh variabel lingkungan PORT.

Aplikasi Anda sudah jadi dan siap dimasukkan ke dalam container dan diupload ke Container Registry.

Java

  1. Instal JDK untuk Java SE 8 atau yang lebih baru dan CURL.

    Perhatikan bahwa kita hanya perlu melakukan langkah ini untuk membuat project web baru pada langkah berikutnya. Dockerfile, yang akan dijelaskan nanti, akan memuat semua dependensi ke dalam container.

  2. Dari konsol, buat project web kosong baru menggunakan perintah cURL dan perintah ekstrak:

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

    Langkah ini menghasilkan project SpringBoot.

  3. Perbarui class SpringBootApplication di src/main/java/com/example/helloworld/HelloworldApplication.java dengan menambahkan @RestController untuk menangani pemetaan /, serta tambahkan kolom @Value untuk menyediakan variabel lingkungan 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

    Kode ini menghasilkan server web dasar yang memantau port yang ditentukan oleh variabel lingkungan PORT.

Aplikasi Anda sudah jadi dan siap dimasukkan ke dalam container dan diupload ke Container Registry.

Langkah 2: Masukkan aplikasi ke dalam container dan upload ke Container Registry

  1. Masukkan aplikasi contoh ke dalam container dengan membuat file baru bernama Dockerfile di direktori yang sama dengan file sumbernya. Salin konten berikut ke file Anda.

    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. Bangun image container Anda menggunakan Cloud Build dengan menjalankan perintah berikut dari direktori yang memuat Dockerfile Anda:

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

    Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi nama image
    (gcr.io/PROJECT_ID/helloworld).

Image container sekarang disimpan di Container Registry dan dapat digunakan kembali jika diinginkan.

Perhatikan bahwa, sebagai pengganti Cloud Build, Anda dapat menggunakan versi Docker yang diinstal secara lokal untuk membangun container secara lokal.

Langkah 3: Deploy image container ke Cloud Run

  1. Deploy menggunakan perintah berikut:

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

  2. Saat diminta:

Untuk performa terbaik, lakukan kolokasi layanan Cloud Run dengan Hosting menggunakan region berikut:

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

Penulisan ulang ke Cloud Run dari Hosting didukung di region berikut:

  • 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. Tunggu beberapa saat sampai proses deploy selesai. Jika berhasil, command line akan menampilkan URL layanan. Contoh: https://helloworld-RANDOM_HASH-us-central1.a.run.app

  2. Buka container yang telah di-deploy dengan membuka URL layanan di browser web.

Langkah selanjutnya akan memandu Anda mengakses aplikasi dalam container ini dari URL Firebase Hosting sehingga aplikasi tersebut dapat menghasilkan konten dinamis untuk situs Anda yang dihosting oleh Firebase.

Langkah 4: Arahkan permintaan hosting ke aplikasi dalam container Anda

Dengan aturan penulisan ulang, Anda dapat mengarahkan permintaan yang cocok dengan pola tertentu ke satu tujuan.

Contoh berikut menunjukkan cara mengarahkan semua permintaan dari halaman /helloworld di situs Hosting Anda untuk memicu penyiapan dan pengoperasian instance container helloworld Anda.

  1. Pastikan bahwa:

    Untuk mendapatkan petunjuk terperinci tentang cara menginstal CLI dan melakukan inisialisasi Hosting, lihat Panduan Memulai Hosting.

  2. Buka file firebase.json Anda.

  3. Tambahkan konfigurasi rewrite berikut di bawah bagian 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. Deploy konfigurasi hosting tersebut ke situs Anda dengan menjalankan perintah berikut dari root direktori project Anda:

    firebase deploy --only hosting

Container Anda sekarang dapat dijangkau melalui URL berikut:

  • Subdomain Firebase Anda:
    PROJECT_ID.web.app/ dan PROJECT_ID.firebaseapp.com/

  • Semua domain kustom yang terhubung:
    CUSTOM_DOMAIN/

Buka halaman konfigurasi Hosting untuk mengetahui penjelasan selengkapnya tentang aturan penulisan ulang. Anda juga dapat mempelajari urutan prioritas respons untuk berbagai konfigurasi Hosting.

Menguji secara lokal

Selama pengembangan, Anda dapat menjalankan dan menguji image container secara lokal. Untuk mendapatkan petunjuk terperinci, kunjungi dokumentasi Cloud Run.

Langkah berikutnya