Buka konsol

Menampilkan konten dinamis dan menghosting microservice dengan Cloud Run

Pasangkan Cloud Run dengan Firebase Hosting untuk membuat dan menampilkan konten dinamis atau membuat REST API sebagai layanan mikro.

Menggunakan Cloud Run, Anda dapat menerapkan aplikasi yang dikemas dalam image container. Selanjutnya, 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 memiliki fleksibilitas untuk menggunakan bahasa pemrograman dan framework pilihan Anda.
  • Cloud Run meningkatkan skala image container secara otomatis dan horizontal untuk menangani permintaan yang diterima, lalu menurunkan skala saat permintaan berkurang.
  • Anda hanya membayar untuk CPU, memori, dan jaringan yang terpakai selama penanganan permintaan.

Untuk contoh kasus penggunaan dan sampel Cloud Run yang diintegrasikan dengan Firebase Hosting, lihat ringkasan tanpa server kami.


Panduan ini menunjukkan cara:

  1. Menulis aplikasi Hello World sederhana
  2. Memasukkan aplikasi ke dalam container dan menguploadnya ke Container Registry
  3. Menerapkan 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, mengaktifkan Cloud Run API, dan menginstal fitur command-line gcloud.

Menyiapkan penagihan untuk project Anda

Cloud Run memang menawarkan kuota penggunaan gratis, tetapi Anda tetap harus memiliki akun penagihan yang terkait dengan project Firebase Anda agar dapat menggunakan atau mencoba Cloud Run.

Mengaktifkan API dan menginstal SDK

  1. Aktifkan Cloud Run API di konsol Google API:

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

    2. Saat diminta, pilih project Firebase Anda.

    3. Klik Aktifkan pada halaman Cloud Run API.

  2. Instal dan inisialisasi Google Cloud SDK.

Menginstal komponen gcloud beta

  1. Jalankan perintah berikut untuk menginstal komponen gcloud beta:

    gcloud components install beta
  2. Perbarui komponen:

    gcloud components update
  3. Pastikan bahwa fitur gcloud dikonfigurasi untuk project yang tepat:

    gcloud config list

Langkah 1: Tulis aplikasi sampel

Perhatikan bahwa Cloud Run mendukung banyak bahasa lain selain yang ditampilkan dalam sampel berikut.

Go

  1. Buat direktori baru bernama helloworld-go, lalu ubah direktori menjadi:

    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("Hello world received a request.")
    	target := os.Getenv("TARGET")
    	if target == "" {
    		target = "World"
    	}
    	fmt.Fprintf(w, "Hello %s!\n", target)
    }
    
    func main() {
    	log.Print("Hello world sample started.")
    
    	http.HandleFunc("/", handler)
    
    	port := os.Getenv("PORT")
    	if port == "" {
    		port = "8080"
    	}
    
    	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
    }
    

    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 ubah direktori menjadi:

    mkdir helloworld-nodejs
    cd helloworld-nodejs
  2. Buat file package.json dengan isi 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.16.4"
      }
    }
    
  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}!`);
    });
    
    const port = process.env.PORT || 8080;
    app.listen(port, () => {
      console.log('Hello world listening on port', port);
    });
    

    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 ubah direktori menjadi:

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

    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 Java SE 8 atau JDK dan CURL yang lebih baru.

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

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

    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 / dan juga menambahkan 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 message;
    
    	@RestController
    	class HelloworldController {
    		@GetMapping("/")
    		String hello() {
    			return "Hello " + message + "!";
    		}
    	}
    
    	public static void main(String[] args) {
    		SpringApplication.run(HelloworldApplication.class, args);
    	}
    }
    

    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 sampel 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 offical Golang image to create a build artifact.
    # This is based on Debian and sets the GOPATH to /go.
    # https://hub.docker.com/_/golang
    FROM golang as builder
    
    # Copy local code to the container image.
    WORKDIR /go/src/github.com/knative/docs/helloworld
    COPY . .
    
    # Build the outyet command inside the container.
    # (You may fetch or manage dependencies here,
    # either manually or with a tool like "godep".)
    RUN CGO_ENABLED=0 GOOS=linux go build -v -o helloworld
    
    # Use a Docker multi-stage build to create a lean production image.
    # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
    FROM alpine
    
    # Copy the binary to the production image from the builder stage.
    COPY --from=builder /go/src/github.com/knative/docs/helloworld/helloworld /helloworld
    
    # Service must listen to $PORT environment variable.
    # This default value facilitates local development.
    ENV PORT 8080
    
    # Run the web service on container startup.
    CMD ["/helloworld"]
    

    Node.js

    # Use the official Node.js 10 image.
    # https://hub.docker.com/_/node
    FROM node:10
    
    # 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 . .
    
    # Service must listen to $PORT environment variable.
    # This default value facilitates local development.
    ENV PORT 8080
    
    # Run the web service on container startup.
    CMD [ "npm", "start" ]
    

    Python

    # Use the official Python image.
    # https://hub.docker.com/_/python
    FROM python
    
    # Copy local code to the container image.
    ENV APP_HOME /app
    WORKDIR $APP_HOME
    COPY . .
    
    # Install production dependencies.
    RUN pip install Flask gunicorn
    
    # Service must listen to $PORT environment variable.
    # This default value facilitates local development.
    ENV PORT 8080
    
    # 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 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
    
    # Service must listen to $PORT environment variable.
    # This default value facilitates local development.
    ENV PORT 8080
    
    # Run the web service on container startup.
    CMD ["java","-Djava.security.egd=file:/dev/./urandom","-Dserver.port=${PORT}","-jar","/helloworld.jar"]
    

  2. Buat image container menggunakan Cloud Build dengan menjalankan perintah berikut dari direktori yang memuat Dockerfile Anda:

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

    Setelah berhasil, Anda akan melihat pesan SUKSES yang berisi nama image
    (gcr.io/projectID/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 membuat container secara lokal.

Langkah 3: Terapkan image container ke Cloud Run

  1. Terapkan menggunakan perintah berikut:

    gcloud beta run deploy --image gcr.io/projectID/helloworld

  2. Saat diminta:

  3. Tunggu beberapa saat sampai penerapan selesai. Jika berhasil, command line akan menampilkan URL layanan. Contoh:

    https://helloworld-random_hash-us-central1.a.run.app
  4. Akses container yang telah diterapkan dengan membuka URL layanan di browser web.

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

Langkah 4: Arahkan permintaan hosting ke aplikasi dalam container

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 peluncuran instance container helloworld.

  1. Pastikan bahwa:

    Untuk petunjuk terperinci cara menginstal CLI dan menginisialisasi Hosting, lihat panduan Memulai Hosting.

  2. Buka file firebase.json Anda.

  3. Tambahkan konfigurasi rewrite berikut di bagian hosting:

    "hosting": {
      // ...
    
      // Add the "rewrites" attribute within "hosting"
      "rewrites": [ {
        "source": "**",
        "run": {
          "serviceId": "helloworld",  // "service name" (from when you deployed the container image)
          "region": "us-central1"     // optional (if omitted, default is us-central1)
        }
      } ]
    }
    
  4. Terapkan konfigurasi hosting ini ke situs Anda dengan menjalankan perintah berikut dari root direktori project Anda:

    firebase deploy

Container Anda sekarang dapat dijangkau melalui URL berikut:

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

  • Semua domain kustom yang terhubung: custom-domain/helloworld

Buka halaman konfigurasi Hosting untuk 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 petunjuk terperinci, baca dokumentasi Cloud Run.

Langkah berikutnya