Servir du contenu dynamique et héberger 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 comme des microservices.

À l'aide de Cloud Run , vous pouvez déployer une application empaquetée dans une image de conteneur. 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 langages (notamment Go, Node.js, Python et Java), ce qui vous permet d'utiliser le langage de programmation et le framework de votre choix.
Cloud Run met à l'échelle automatiquement et horizontalement l' image de votre conteneur pour gérer les demandes reçues, puis diminue lorsque la demande diminue.
Vous ne payez que pour le processeur, la mémoire et le réseau consommés lors du traitement des demandes.

Par exemple, des cas d'utilisation et des exemples pour Cloud Run intégré à Firebase Hosting, consultez notre présentation sans serveur .

Ce guide vous montre comment:

Rédiger une application Hello World simple
Conteneuriser une application et la télécharger dans Container Registry
Déployer l'image du conteneur sur Cloud Run
Demandes d'hébergement directes vers votre application conteneurisée

Notez que pour améliorer les performances de diffusion du contenu dynamique, vous pouvez éventuellement régler vos paramètres de cache .

Avant que tu commences

Avant d'utiliser Cloud Run, vous devez effectuer certaines tâches initiales, notamment la configuration d'un compte Cloud Billing, l'activation de l'API Cloud Run et l'installation de l'outil de ligne de commande gcloud .

Configurer la facturation de votre projet

Cloud Run offre un quota d'utilisation gratuit , mais vous devez toujours disposer d'un compte Cloud Billing associé à votre projet Firebase pour utiliser ou essayer Cloud Run.

Activez l'API et installez le SDK

Activez l'API Cloud Run dans la console des API Google:
1. Ouvrez la page API Cloud Run dans la console des API Google.
2. Lorsque vous y êtes invité, sélectionnez votre projet Firebase.
3. Cliquez sur Activer sur la page de l'API Cloud Run.
Installez et initialisez le SDK Cloud.

Installez le composant bêta de gcloud

Exécutez la commande suivante pour installer le composant gcloud beta:
```
gcloud components install beta
```
Mettre à jour les composants:
```
gcloud components update
```
Vérifiez que l'outil gcloud est configuré pour le bon projet:
```
gcloud config list
```

Étape 1 : rédigez l'exemple d'application

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

Va

Créez un nouveau répertoire nommé helloworld-go , puis changez de répertoire dans celui-ci:
```
mkdir helloworld-go
```
```
cd helloworld-go
```

Créez 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))
}
helloworld.go

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

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

Node.js

Créez un nouveau répertoire nommé helloworld-nodejs , puis changez de répertoire dans celui-ci:
```
mkdir helloworld-nodejs
```
```
cd helloworld-nodejs
```

Créez un fichier package.json 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"
  }
}
package.json

Créez 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);
});
index.js

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

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

Python

Créez un nouveau répertoire nommé helloworld-python , puis changez de répertoire dans celui-ci:
```
mkdir helloworld-python
```
```
cd helloworld-python
```

Créez 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)))
app.py

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

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

Java

Installez Java SE 8 ou une version ultérieure 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, décrit plus loin, chargera toutes les dépendances dans le conteneur.

Depuis la console, créez un nouveau projet Web vide en utilisant cURL puis décompressez les commandes:

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.

Mettez à jour la classe SpringBootApplication dans src/main/java/com/example/helloworld/HelloworldApplication.java en ajoutant un @RestController pour gérer le / mapping et ajoutez également un champ @Value pour fournir la variable d'environnement 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);
  }
}
HelloworldApplication.java

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

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

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

Conteneurisez l'exemple d'application 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.

Va

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

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

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
Dockerfile

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

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 qu'au lieu de Cloud Build, vous pouvez utiliser une version installée localement de Docker pour créer votre conteneur localement .

Étape 3 : déployer l'image du conteneur sur Cloud Run

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

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

Lorsque vous y êtes invité:
- Sélectionnez une région (par exemple us-central1 )
- Confirmez le nom du service (par exemple, helloworld )
- Répondez Y pour autoriser les appels non authentifiés
Important: souvenez-vous de la région et du nom du service afin de pouvoir utiliser ces valeurs lors de la définition de la region et de l' firebase.json serviceID , respectivement, dans la règle de réécriture firebase.json ultérieurement.
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
Accédez à votre conteneur déployé en ouvrant l'URL du service dans un navigateur Web.

L'étape suivante vous explique comment accéder à cette application conteneurisée à partir d'une URL d'hébergement Firebase afin qu'elle puisse générer du contenu dynamique pour votre site hébergé par Firebase.

Étape 4: Dirigez les demandes d'hébergement vers votre application conteneurisée

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

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

Sois sûr que:
- Vous disposez de la dernière version de l'interface de ligne de commande Firebase .
- Vous avez initialisé Firebase Hosting.
Pour obtenir des instructions détaillées sur l'installation de l'interface de ligne de commande et l'initialisation de l'hébergement, consultez le guide Prise en main de l'hébergement .
Ouvrez votre fichier firebase.json .

Ajoutez la configuration de rewrite suivante dans la section d' 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)
    }
  } ]
}

Déployez votre configuration d'hébergement sur votre site en exécutant la commande suivante à partir de 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 domaines personnalisés connecté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 savoir plus sur l' ordre de priorité des réponses pour diverses 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 Cloud Run .

Prochaines étapes

Configurez la mise en cache de votre contenu dynamique sur un CDN global.
Interagissez avec d'autres services Firebase à l'aide du SDK Firebase Admin .
En savoir plus sur Cloud Run, y compris des guides détaillés sur la configuration, la gestion et la configuration des conteneurs.
Passez en revue la tarification et les quotas et limites de Cloud Run