Firebase Summit で発表されたすべての情報をご覧ください。Firebase を使用してアプリ開発を加速し、自信を持ってアプリを実行する方法を紹介しています。詳細

Cloud Runを使用して、動的コンテンツを提供し、マイクロサービスをホストします

Cloud Run と Firebase Hosting を組み合わせて、動的コンテンツを生成して提供したり、REST API をマイクロサービスとして構築したりします。

Cloud Runを使用すると、コンテナ イメージにパッケージ化されたアプリケーションをデプロイできます。次に、Firebase Hosting を使用して、コンテナ化されたアプリをトリガーするように HTTPS リクエストを送信できます。

  • Cloud Run は複数の言語(Go、Node.js、Python、Java など) をサポートしているため、選択したプログラミング言語とフレームワークを柔軟に使用できます。
  • Cloud Run は、受信したリクエストを処理するためにコンテナ イメージを自動的かつ水平方向にスケーリングし、需要が減少するとスケールダウンします。
  • リクエストの処理中に消費された CPU、メモリ、およびネットワークに対してのみ料金が発生します。

Firebase Hosting と統合された Cloud Run の使用例とサンプルについては、サーバーレスの概要をご覧ください。


このガイドでは、次の方法について説明します。

  1. 簡単な Hello World アプリケーションを作成する
  2. アプリをコンテナ化し、Container Registry にアップロードする
  3. コンテナ イメージを Cloud Run にデプロイする
  4. コンテナ化されたアプリへのダイレクト ホスティング リクエスト

動的コンテンツの提供のパフォーマンスを向上させるために、必要に応じてキャッシュ設定を調整できます。

あなたが始める前に

Cloud Run を使用する前に、Cloud 請求先アカウントの設定、Cloud Run API の有効化、 gcloudコマンドライン ツールのインストールなど、いくつかの初期タスクを完了する必要があります。

プロジェクトの請求を設定する

Cloud Run は無料の使用割り当てを提供しますが、Cloud Run を使用または試すには、Firebase プロジェクトに関連付けられたCloud 請求先アカウントが必要です。

API を有効にして SDK をインストールする

  1. Google API コンソールで Cloud Run API を有効にします。

    1. Google API コンソールでCloud Run API ページを開きます。

    2. プロンプトが表示されたら、Firebase プロジェクトを選択します。

    3. Cloud Run API ページで [有効にする] をクリックします。

  2. Cloud SDKをインストールして初期化します。

  3. gcloudツールが正しいプロジェクト用に構成されていることを確認します。

    gcloud config list

ステップ 1 : サンプル アプリケーションを作成する

Cloud Run は、次のサンプルに示されている言語に加えて、他の多くの言語をサポートしていることに注意してください。

行け

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

    このコードは、 PORT環境変数で定義されたポートをリッスンする基本的な Web サーバーを作成します。

アプリが完成し、コンテナー化して Container Registry にアップロードする準備が整いました。

Node.js

  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.16.4"
      }
    }
    
  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);
    });
    

    このコードは、 PORT環境変数で定義されたポートをリッスンする基本的な Web サーバーを作成します。

アプリが完成し、コンテナー化して Container Registry にアップロードする準備が整いました。

パイソン

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

    このコードは、 PORT環境変数で定義されたポートをリッスンする基本的な Web サーバーを作成します。

アプリが完成し、コンテナー化して Container Registry にアップロードする準備が整いました。

ジャワ

  1. Java SE 8 以降の JDKおよびCURLをインストールします。

    これは、次のステップで新しい Web プロジェクトを作成するためにのみ行う必要があることに注意してください。後で説明する Dockerfile は、すべての依存関係をコンテナーに読み込みます。

  2. コンソールから、cURL を使用して新しい空の Web プロジェクトを作成し、コマンドを解凍します。

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

    これにより、SpringBoot プロジェクトが作成されます。

  3. @RestController を追加して/マッピングを処理し、 @Value @RestControllerを追加してTARGET環境変数を提供することにより、 src/main/java/com/example/helloworld/HelloworldApplication.javaSpringBootApplicationクラスを更新します。

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

    このコードは、 PORT環境変数で定義されたポートをリッスンする基本的な Web サーバーを作成します。

アプリが完成し、コンテナー化して Container Registry にアップロードする準備が整いました。

ステップ 2 : アプリをコンテナ化し、Container Registry にアップロードする

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

    パイソン

    # 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
    

    ジャワ

    # 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. Dockerfile を含むディレクトリから次のコマンドを実行して、Cloud Build を使用してコンテナ イメージをビルドします。

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

    成功すると、イメージ名を含む SUCCESS メッセージが表示されます。
    ( gcr.io/ PROJECT_ID /helloworld )。

コンテナ イメージが Container Registry に保存され、必要に応じて再利用できるようになりました。

Cloud Build の代わりに、ローカルにインストールされたバージョンの Docker を使用して、コンテナをローカルにビルドできます

ステップ 3 : コンテナ イメージを Cloud Run にデプロイする

  1. 次のコマンドを使用してデプロイします。

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

  2. プロンプトが表示されたら:

  3. デプロイが完了するまでしばらく待ちます。成功すると、コマンド ラインにサービス URL が表示されます。例: https://helloworld- RANDOM_HASH -us-central1.a.run.app

  4. Web ブラウザーでサービス URL を開いて、デプロイされたコンテナーにアクセスします。

次のステップでは、Firebase Hosting URL からこのコンテナー化されたアプリにアクセスして、Firebase でホストされているサイトの動的コンテンツを生成できるようにする方法について説明します。

ステップ 4:コンテナー化されたアプリにホスティング リクエストを送信する

書き換えルールを使用すると、特定のパターンに一致するリクエストを 1 つの宛先に送信できます。

次の例は、ホスティング サイトのページ/helloworldからのすべての要求を転送して、 helloworldコンテナー インスタンスの起動と実行をトリガーする方法を示しています。

  1. 次のことを確認してください。

    CLI のインストールとホスティングの初期化の詳細な手順については、ホスティングの入門ガイドを参照してください。

  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)
        }
      } ]
    }
    
  4. プロジェクト ディレクトリのルートから次のコマンドを実行して、ホスティング構成をサイトにデプロイします。

    firebase deploy

次の URL からコンテナにアクセスできるようになりました。

  • Firebase サブドメイン:
    PROJECT_ID .web.app/およびPROJECT_ID .firebaseapp.com/

  • 接続されているカスタム ドメイン:
    CUSTOM_DOMAIN /

書き換えルールの詳細については、ホスティング構成ページをご覧ください。また、さまざまな Hosting 構成に対する応答の優先順位についても学ぶことができます。

ローカルでテストする

開発中は、コンテナー イメージをローカルで実行してテストできます。詳細な手順については、 Cloud Run のドキュメントをご覧ください。

次のステップ