Ikuti semua informasi yang diumumkan di Firebase Summit, dan pelajari bagaimana Firebase dapat membantu Anda mempercepat pengembangan aplikasi dan menjalankan aplikasi dengan percaya diri. Pelajari Lebih Lanjut

Sajikan konten dinamis dan host layanan mikro dengan Cloud Run

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

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

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

  • Cloud Run mendukung beberapa bahasa (termasuk Go, Node.js, Python, dan Java), memberi Anda fleksibilitas untuk menggunakan bahasa pemrograman dan kerangka kerja pilihan Anda.
  • Cloud Run secara otomatis dan horizontal menskalakan image container Anda untuk menangani permintaan yang diterima, lalu menurunkan skalanya saat permintaan menurun.
  • Anda hanya membayar untuk CPU, memori, dan jaringan yang digunakan selama penanganan permintaan.

Misalnya kasus penggunaan dan contoh untuk Cloud Run yang terintegrasi dengan Firebase Hosting, kunjungi ikhtisar tanpa server kami.


Panduan ini menunjukkan kepada Anda cara:

  1. Tulis aplikasi Hello World sederhana
  2. Menampung aplikasi dan mengunggahnya ke Container Registry
  3. Deploy image container ke Cloud Run
  4. Mengarahkan permintaan Hosting ke aplikasi kemas Anda

Perhatikan bahwa untuk meningkatkan kinerja penyajian konten dinamis, Anda dapat menyetel setelan tembolok secara opsional .

Sebelum kamu memulai

Sebelum menggunakan Cloud Run, Anda harus menyelesaikan beberapa tugas awal, termasuk menyiapkan akun Penagihan Cloud, mengaktifkan Cloud Run API, dan menginstal alat baris perintah gcloud .

Siapkan penagihan untuk proyek Anda

Cloud Run menawarkan kuota penggunaan gratis , tetapi Anda masih harus memiliki akun Penagihan Cloud yang terkait dengan proyek Firebase Anda untuk menggunakan atau mencoba Cloud Run.

Aktifkan API dan instal SDK

  1. Aktifkan Cloud Run API di konsol Google API:

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

    2. Saat diminta, pilih proyek Firebase Anda.

    3. Klik Aktifkan di halaman Cloud Run API.

  2. Instal dan inisialisasi Cloud SDK.

  3. Periksa apakah alat gcloud dikonfigurasi untuk proyek yang benar:

    gcloud config list

Langkah 1 : Tulis aplikasi sampel

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

Pergi

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

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

    Kode ini membuat server web dasar yang mendengarkan pada port yang ditentukan oleh variabel lingkungan PORT .

Aplikasi Anda telah selesai dan siap untuk dimasukkan ke dalam container dan diunggah ke Container Registry.

Node.js

  1. Buat direktori baru bernama helloworld-nodejs , lalu ubah direktori ke dalamnya:

    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.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}!\n`);
    });
    
    const port = process.env.PORT || 8080;
    app.listen(port, () => {
      console.log('Hello world listening on port', port);
    });
    

    Kode ini membuat server web dasar yang mendengarkan pada port yang ditentukan oleh variabel lingkungan PORT .

Aplikasi Anda telah selesai dan siap untuk dimasukkan ke dalam container dan diunggah ke Container Registry.

Python

  1. Buat direktori baru bernama helloworld-python , lalu ubah direktori ke dalamnya:

    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 membuat server web dasar yang mendengarkan pada port yang ditentukan oleh variabel lingkungan PORT .

Aplikasi Anda telah selesai dan siap untuk dimasukkan ke dalam container dan diunggah ke Container Registry.

Jawa

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

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

  2. Dari konsol, buat proyek web kosong baru menggunakan cURL lalu unzip perintah:

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

    Ini menciptakan proyek SpringBoot.

  3. Perbarui kelas SpringBootApplication di src/main/java/com/example/helloworld/HelloworldApplication.java dengan menambahkan @RestController untuk menangani / pemetaan dan juga menambahkan bidang @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);
      }
    }
    

    Kode ini membuat server web dasar yang mendengarkan pada port yang ditentukan oleh variabel lingkungan PORT .

Aplikasi Anda telah selesai dan siap untuk dimasukkan ke dalam container dan diunggah ke Container Registry.

Langkah 2 : Masukkan aplikasi dan unggah ke Container Registry

  1. Tempatkan aplikasi sampel dengan membuat file baru bernama Dockerfile di direktori yang sama dengan file sumber. Salin konten berikut ke dalam file Anda.

    Pergi

    # Use the official Golang image to create a build artifact.
    # This is based on Debian and sets the GOPATH to /go.
    FROM golang:1.13 as builder
    
    # 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=linux 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"]
    

    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" ]
    

    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
    

    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"]
    

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

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

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

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

Perhatikan bahwa, alih-alih Cloud Build, Anda dapat menggunakan versi Docker yang diinstal secara lokal untuk membuat container Anda 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:

  3. Tunggu beberapa saat hingga penerapan selesai. Jika berhasil, baris perintah menampilkan URL layanan. Misalnya: https://helloworld- RANDOM_HASH -us-central1.a.run.app

  4. Kunjungi penampung yang Anda terapkan dengan membuka URL layanan di browser web.

Langkah berikutnya memandu Anda melalui cara mengakses aplikasi dalam container ini dari URL Firebase Hosting sehingga dapat menghasilkan konten dinamis untuk situs yang dihosting Firebase.

Langkah 4: Arahkan permintaan hosting ke aplikasi kemas 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 startup dan menjalankan instance container helloworld Anda.

  1. Pastikan bahwa:

    Untuk petunjuk rinci tentang menginstal CLI dan menginisialisasi Hosting, lihat panduan Memulai untuk 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)
        }
      } ]
    }
    
  4. Terapkan konfigurasi hosting Anda ke situs Anda dengan menjalankan perintah berikut dari akar direktori proyek Anda:

    firebase deploy

Penampung Anda sekarang dapat dijangkau melalui URL berikut:

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

  • Setiap domain khusus yang terhubung :
    CUSTOM_DOMAIN /

Kunjungi halaman konfigurasi Hosting untuk detail selengkapnya tentang aturan penulisan ulang . Anda juga dapat mempelajari tentang urutan prioritas tanggapan untuk berbagai konfigurasi Hosting.

Uji secara lokal

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

Langkah selanjutnya