Catch up on everthing we announced at this year's Firebase Summit. Learn more

Diffusez du contenu dynamique et hébergez des microservices avec Cloud Run

Associez Cloud Run à Firebase Hosting pour générer et diffuser votre contenu dynamique ou créer des API REST en tant que microservices.

En utilisant Nuage Run , vous pouvez déployer une application packagée dans une image contenant. Ensuite, en utilisant Firebase Hosting, vous pouvez diriger les requêtes HTTPS pour déclencher votre application conteneurisée.

  • Cloud Run prend en charge plusieurs langues (y compris Go, Node.js, Python et Java), vous donnant la possibilité d'utiliser le langage de programmation et le cadre de votre choix.
  • Cloud Exécuter automatiquement et échelles horizontalement l' image de votre conteneur pour traiter les demandes reçues, puis vers le bas lorsque la demande échelles diminue.
  • Vous ne payez pour la CPU, la mémoire et la mise en réseau lors de la manipulation de consumés demande.

Par exemple , les cas d'utilisation et des échantillons pour Cloud Run intégré avec Firebase hébergement, visitez notre aperçu serverless .


Ce guide vous montre comment :

  1. Écrire une simple application Hello World
  2. Conteneuriser une application et l'importer dans Container Registry
  3. Déployer l'image du conteneur sur Cloud Run
  4. Demandes d'hébergement direct à votre application conteneurisée

Notez que pour améliorer les performances de servir le contenu dynamique, vous pouvez éventuellement affiner vos paramètres de cache .

Avant que tu commences

Avant d' utiliser Run - Cloud, vous devez remplir certaines tâches initiales, y compris la création d'un compte de facturation Cloud permettant l'API cloud Run, et l' installation du gcloud outil de ligne de commande.

Configurer la facturation de votre projet

Cloud Run offre quota d'utilisation gratuit , mais vous devez quand même avoir un compte de facturation Cloud associé à votre projet Firebase à utiliser ou essayer Cloud Run.

Activer l'API et installer le SDK

  1. Activez l'API Cloud Run dans la console des API Google :

    1. Ouvrez la page Cloud API Run dans la console API Google.

    2. Lorsque vous y êtes invité, sélectionnez votre projet Firebase.

    3. Cliquez sur Activer sur la page Cloud API Run.

  2. Installer et initialiser le SDK Cloud.

  3. Vérifiez que le gcloud outil est configuré pour le bon projet:

    gcloud config list

Étape 1: Écrivez l'application échantillon

Notez que le Cloud Run prend en charge de nombreuses autres langues en plus des langues indiquées dans l'exemple suivant.

Aller

  1. Créer un nouveau répertoire nommé helloworld-go , puis changer le répertoire en elle:

    mkdir helloworld-go
    cd helloworld-go
  2. Créer un nouveau fichier nommé helloworld.go , puis ajoutez le code suivant:

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

    Ce code crée un serveur Web de base qui écoute sur le port défini par le PORT variable d'environnement.

Votre application est terminée et prête à être conteneurisée et importée dans Container Registry.

Node.js

  1. Créer un nouveau répertoire nommé helloworld-nodejs , puis changer le répertoire en elle:

    mkdir helloworld-nodejs
    cd helloworld-nodejs
  2. Créer un package.json fichier avec le contenu suivant:

    {
      "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. Créer un nouveau fichier nommé index.js , puis ajoutez le code suivant:

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

    Ce code crée un serveur Web de base qui écoute sur le port défini par le PORT variable d'environnement.

Votre application est terminée et prête à être conteneurisée et importée dans Container Registry.

Python

  1. Créer un nouveau répertoire nommé helloworld-python , puis changer le répertoire en elle:

    mkdir helloworld-python
    cd helloworld-python
  2. Créer un nouveau fichier nommé app.py , puis ajoutez le code suivant:

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

    Ce code crée un serveur Web de base qui écoute sur le port défini par le PORT variable d'environnement.

Votre application est terminée et prête à être conteneurisée et importée dans Container Registry.

Java

  1. Installer Java SE 8 ou plus JDK et CURL .

    Notez que nous n'avons besoin de le faire que pour créer le nouveau projet Web à l'étape suivante. Le Dockerfile, qui est décrit plus loin, chargera toutes les dépendances dans le conteneur.

  2. Depuis la console, créez un nouveau projet Web vide à l'aide des commandes cURL puis décompressez :

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

    Cela crée un projet SpringBoot.

  3. Mettre à jour la SpringBootApplication classe dans src/main/java/com/example/helloworld/HelloworldApplication.java en ajoutant un @RestController pour gérer la / cartographie et également ajouter un @Value champ pour l' TARGET variable d' environnement:

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

    Ce code crée un serveur Web de base qui écoute sur le port défini par le PORT variable d'environnement.

Votre application est terminée et prête à être conteneurisée et importée dans Container Registry.

Étape 2: conteneuriser une application et la télécharger Container Registre

  1. Conteneuriser l'application exemple en créant un nouveau fichier nommé Dockerfile dans le même répertoire que les fichiers source. Copiez le contenu suivant dans votre fichier.

    Aller

    # 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
    

    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. Créez votre image de conteneur à l'aide de Cloud Build en exécutant la commande suivante à partir du répertoire contenant votre Dockerfile :

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

    En cas de succès, vous verrez un message SUCCESS contenant le nom de l'image
    ( gcr.io/ PROJECT_ID /helloworld ).

L'image du conteneur est désormais stockée dans Container Registry et peut être réutilisée si vous le souhaitez.

Notez que, au lieu de construction Cloud, vous pouvez utiliser une version installée localement Docker pour construire votre conteneur localement .

Étape 3: Déploiement de l'image du conteneur Cloud Run

  1. Déployez à l'aide de la commande suivante :

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

  2. Lorsque vous y êtes invité :

  3. Attendez quelques instants que le déploiement se termine. En cas de succès, la ligne de commande affiche l'URL du service. Par exemple: https://helloworld- RANDOM_HASH -us-central1.a.run.app

  4. Visitez votre conteneur déployé en ouvrant l'URL du service dans un navigateur Web.

L'étape suivante vous guide à travers la façon d'accéder à cette application conteneurisées à partir d' une URL d' hébergement Firebase afin qu'il puisse générer du contenu dynamique pour votre site hébergé Firebase.

Étape 4: demandes d'hébergement direct à votre application conteneurisées

Avec des règles de réécriture , vous pouvez diriger les demandes qui correspondent à des modèles spécifiques à une seule destination.

L'exemple suivant montre comment toutes les requêtes de la page /helloworld sur votre site d' hébergement pour déclencher le démarrage et le fonctionnement de votre helloworld instance de conteneur.

  1. Sois sûr que:

    Pour obtenir des instructions détaillées sur l' installation de la CLI et l' initialisation d' hébergement, consultez le Get Started pour l' hébergement .

  2. Ouvrez votre firebase.json fichier .

  3. Ajoutez ce qui suit rewrite configuration sous l' hosting section:

    "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. Déployez votre configuration d'hébergement sur votre site en exécutant la commande suivante depuis la racine de votre répertoire de projet :

    firebase deploy

Votre conteneur est désormais accessible via les URL suivantes :

  • Vos sous-domaines Firebase :
    PROJECT_ID .web.app/ et PROJECT_ID .firebaseapp.com/

  • Tous les connectés domaines personnalisés :
    CUSTOM_DOMAIN /

Visitez la page de configuration d' hébergement pour plus de détails sur les règles de réécriture . Vous pouvez également en apprendre davantage sur l' ordre de priorité des réponses pour différentes configurations d' hébergement.

Tester localement

Pendant le développement, vous pouvez exécuter et tester votre image de conteneur localement. Pour obtenir des instructions détaillées, consultez la documentation Run - Cloud .

Prochaines étapes