Gestisci contenuti dinamici e ospita microservizi con Cloud Run

Accoppia Cloud Run con Firebase Hosting per generare e pubblicare i tuoi contenuti dinamici o per creare API REST come microservizi.

Con Cloud Run puoi eseguire il deployment di un'applicazione pacchettizzata in un'immagine container. Quindi, utilizzando Firebase Hosting, puoi indirizzare le richieste HTTPS in modo che attivino la tua app containerizzata.

  • Cloud Run supporta diversi linguaggi (tra cui Go, Node.js, Python e Java), offrendoti la flessibilità di utilizzare il linguaggio di programmazione e il framework che preferisci.
  • Cloud Run scala automaticamente e orizzontalmente l'immagine container per gestire le richieste ricevute, quindi fa lo scale down quando la domanda diminuisce.
  • Paghi solo per la CPU, la memoria e le risorse di rete utilizzate durante la gestione delle richieste.

Per casi d'uso e esempi di Cloud Run integrati con Firebase Hosting, consulta la nostra panoramica del serverless.


Questa guida illustra come:

  1. Scrivere una semplice applicazione Hello World
  2. Containerizza un'app e caricala su Container Registry
  3. Esegui il deployment dell'immagine container in Cloud Run
  4. Indirizza le richieste Hosting alla tua app containerizzata

Tieni presente che, per migliorare il rendimento della pubblicazione di contenuti dinamici, puoi optionally ottimizzare le impostazioni della cache.

Prima di iniziare

Prima di utilizzare Cloud Run, devi completare alcune attività iniziali, tra cui la configurazione di un account Cloud Billing, l'attivazione dell'API Cloud Run e l'installazione dello strumento a riga di comando gcloud.

Configurare la fatturazione per il progetto

Cloud Run offre una quota di utilizzo gratuita, ma devi comunque avere un account Cloud Billing associato al tuo progetto Firebase per utilizzare o provare Cloud Run.

Attiva l'API e installa l'SDK

  1. Abilita l'API Cloud Run nella console API di Google:

    1. Apri la pagina dell'API Cloud Run nella console API di Google.

    2. Quando richiesto, seleziona il progetto Firebase.

    3. Fai clic su Abilita nella pagina dell'API Cloud Run.

  2. Installa e inizializza Cloud SDK.

  3. Verifica che lo strumento gcloud sia configurato per il progetto corretto:

    gcloud config list

Passaggio 1: scrivi l'applicazione di esempio

Tieni presente che Cloud Run supporta molte altre lingue oltre a quelle mostrate nell'esempio seguente.

Vai

  1. Crea una nuova directory denominata helloworld-go, quindi modificala:

    mkdir helloworld-go
    cd helloworld-go
  2. Crea un nuovo file denominato helloworld.go e aggiungi il seguente codice:

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

    Questo codice crea un server web di base in ascolto sulla porta definita dalla variabile di ambiente PORT.

La tua app è ora completa e pronta per essere containerizzata e caricata su Container Registry.

Node.js

  1. Crea una nuova directory denominata helloworld-nodejs, quindi cambia directory:

    mkdir helloworld-nodejs
    cd helloworld-nodejs
  2. Crea un file package.json con i seguenti contenuti:

    {
      "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.21.1"
      }
    }
    
  3. Crea un nuovo file denominato index.js e aggiungi il seguente codice:

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

    Questo codice crea un server web di base in ascolto sulla porta definita dalla variabile di ambiente PORT.

La tua app è ora completa e pronta per essere containerizzata e caricata su Container Registry.

Python

  1. Crea una nuova directory denominata helloworld-python, quindi cambia directory:

    mkdir helloworld-python
    cd helloworld-python
  2. Crea un nuovo file denominato app.py e aggiungi il seguente codice:

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

    Questo codice crea un server web di base in ascolto sulla porta definita dalla variabile di ambiente PORT.

La tua app è ora completa e pronta per essere containerizzata e caricata su Container Registry.

Java

  1. Installa JDK Java SE 8 o versioni successive e CURL.

    Tieni presente che lo faremo solo per creare il nuovo progetto web nel passaggio successivo. Il file Dockerfile, descritto di seguito, caricherà tutte le dipendenze nel container.

  2. Dalla console, crea un nuovo progetto web vuoto utilizzando i comandi cURL e unzip:

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

    Viene creato un progetto SpringBoot.

  3. Aggiorna la classe SpringBootApplication in src/main/java/com/example/helloworld/HelloworldApplication.java aggiungendo un @RestController per gestire la mappatura / e anche un @Value campo per fornire la variabile di ambiente 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);
      }
    }
    

    Questo codice crea un server web di base in ascolto sulla porta definita dalla variabile di ambiente PORT.

La tua app è completa e pronta per essere containerizzata e caricata su Container Registry.

Passaggio 2: esegui il containerizzazione di un'app e caricala su Container Registry

  1. Containerizza l'app di esempio creando un nuovo file denominato Dockerfile nella stessa directory dei file di origine. Copia i seguenti contenuti nel file.

    Vai

    # 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
    
    # Copy local code to the container image.
    COPY . ./
    
    # Install dependencies and tidy up the go.mod and go.sum files.
    RUN go mod tidy
    
    # 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"]
    

    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
    

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

  2. Crea l'immagine container utilizzando Cloud Build eseguendo il seguente comando dalla directory contenente il file Dockerfile:

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

    In caso di esito positivo, viene visualizzato un messaggio di successo contenente il nome dell'immagine
    (gcr.io/PROJECT_ID/helloworld).

L'immagine del contenitore è ora archiviata in Container Registry e può essere riutilizzata se lo desideri.

Tieni presente che, anziché Cloud Build, puoi utilizzare una versione di Docker installata localmente per creare il container localmente.

Passaggio 3: esegui il deployment dell'immagine container in Cloud Run

  1. Esegui il deployment utilizzando il seguente comando:

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

  2. Quando richiesto:

Per ottenere il massimo rendimento, esegui la colocazione del servizio Cloud Run con Hosting utilizzando le seguenti regioni:

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

Le riscritture in Cloud Run da Hosting sono supportate nelle seguenti regioni:

  • 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. Attendi qualche istante per il completamento del deployment. Se l'operazione riesce, la riga di comando mostra l'URL del servizio. Ad esempio: https://helloworld-RANDOM_HASH-us-central1.a.run.app

  2. Visita il container di cui hai eseguito il deployment aprendo l'URL del servizio in un browser web.

Il passaggio successivo illustra come accedere a questa app containerizzata da un URLFirebase Hosting in modo che possa generare contenuti dinamici per il tuo sito ospitato su Firebase.

Passaggio 4: indirizza le richieste di hosting all'app containerizzata

Con le regole di riscrittura, puoi indirizzare le richieste che corrispondono a pattern specifici a una singola destinazione.

L'esempio seguente mostra come indirizzare tutte le richieste dalla pagina /helloworld sul tuo sito Hosting per attivare l'avvio e l'esecuzione della tua istanza del contenitore helloworld.

  1. Verifica quanto segue:

    Per istruzioni dettagliate sull'installazione della CLI e sull'inizializzazione di Hosting, consulta la guida introduttiva per Hosting.

  2. Apri il file firebase.json.

  3. Aggiungi la seguente configurazione rewrite nella sezione 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. Esegui il deployment della configurazione di hosting sul tuo sito eseguendo il seguente comando dalla radice della directory del progetto:

    firebase deploy --only hosting

Il container ora è raggiungibile tramite i seguenti URL:

  • I tuoi sottodomini Firebase:
    PROJECT_ID.web.app/ e PROJECT_ID.firebaseapp.com/

  • Eventuali domini personalizzati collegati:
    CUSTOM_DOMAIN/

Visita la pagina di configurazione di Hosting per maggiori dettagli sulle regole di riscrittura. Puoi anche scoprire l'ordine di priorità delle risposte per varie configurazioni di Hosting.

Esegui test in locale

Durante lo sviluppo, puoi eseguire e testare l'immagine container localmente. Per istruzioni dettagliate, consulta la documentazione di Cloud Run.

Passaggi successivi