Connecter Firebase App Hosting à un réseau VPC

Le backend Firebase App Hosting peut se connecter à un réseau de cloud privé virtuel (VPC). Cela permet à votre backend Firebase App Hosting d'accéder aux services backend non accessibles à l'aide d'adresses IP publiques, tels que Cloud SQL, Spanner, Cloud Memorystore, Compute Engine ou les microservices internes Kubernetes.

L'accès au VPC n'est disponible qu'au moment de l'exécution (à partir de votre conteneur Cloud Run), et non au moment de la compilation (Cloud Build).

Configurer dans apphosting.yaml

Utilisez le mappage vpcAccess dans votre fichier apphosting.yaml pour configurer l'accès. Utilisez un nom de réseau complet ou un ID. L'utilisation d'ID permet de transférer des données entre les environnements de préproduction et de production avec différents connecteurs/réseaux.

runConfig:
  vpcAccess:
    egress: PRIVATE_RANGES_ONLY # Default value
    networkInterfaces:
      # Specify at least one of network and/or subnetwork
      - network: my-network-id
        subnetwork: my-subnetwork-id

Exemple: Se connecter à Memorystore pour Redis à partir d'une application Next.js

Les systèmes de mise en cache tels que Redis ou Memcached sont couramment utilisés pour créer une couche de mise en cache de données rapide pour une application. Cet exemple vous montre comment configurer Memorystore pour Redis dans le même projet Google Cloud que votre backend Firebase App Hosting et vous connecter à celui-ci à l'aide de l'égresse VPC directe.

Étape 0: Créer une instance Memorystore pour Redis

  1. Accédez à la page Memorystore pour Redis dans la console Google Cloud.
    • Assurez-vous que le même projet que celui que vous utilisez pour Firebase App Hosting est sélectionné.
    • Si vous ne parvenez pas à accéder à cette page, assurez-vous que la facturation est activée pour votre projet et que vous avez activé l'API Memorystore.
  2. Sélectionnez Créer une instance.
  3. Configurez la nouvelle instance avec les paramètres de votre choix. Voici quelques exemples de valeurs que vous pouvez utiliser :
    • Saisissez my-redis-cache sous ID de l'instance.
    • Saisissez Redis cache sous Nom à afficher.
    • Sélectionnez Basique sous le sélecteur de niveau. Le niveau de base désigne un nœud Redis autonome, contrairement au niveau standard qui utilise un nœud dupliqué pour sauvegarder vos données.
    • Choisissez la région de votre backend App Hosting dans le sélecteur Région. Assurez-vous que cette valeur correspond à la région de votre backend.
    • Sélectionnez n'importe quelle zone dans le sélecteur de zone.
    • Saisissez 5 sous Capacité. La capacité de votre instance est alors définie sur 5 Go.
    • Sélectionnez 5.0 sous Version (recommandé).
    • Sélectionnez default dans le sélecteur Réseau autorisé.

Étape 1: Remplacez apphosting.yaml par votre ID de réseau VPC

  1. Accédez à la page Réseaux VPC dans la console Google Cloud.
  2. Recherchez l'ID de réseau VPC de votre instance Memorystore pour Redis (il s'agit souvent de default).

  3. Définissez la configuration de la sortie VPC directe dans apphosting.yaml à l'aide de l'ID de réseau VPC:

    runConfig:
  vpcAccess:
    egress: PRIVATE_RANGES_ONLY # Default value
  networkInterfaces:
    - network: my-network-id

Étape 2: Ajoutez des variables d'environnement qui redirigent votre application vers Redis

  1. Vous trouverez les informations de connexion (hôte et port) dans l'onglet "Connexions" de votre instance Memorystore pour Redis dans la console Google Cloud.

  2. Connectez-vous à Redis avec les variables d'environnement REDISPORT et REDISHOST. Définissez-les dans apphosting.yaml à l'aide des valeurs d'hôte et de port de la console Google Cloud:

    env:
  # Sample only. Use actual values provided by Memorystore
  - variable: REDISPORT
    value: 6379
  - variable: REDISHOST
    value: 10.127.16.3

Étape 3: Utiliser Redis depuis votre application

  1. Installez le package npm redis:

    npm install redis@latest

  2. Accédez à votre cache Redis à partir de votre code. Utilisez les variables d'environnement configurées à l'étape précédente. Par exemple, voici comment lire à partir d'un cache dans un gestionnaire de route Next.js:

    • src/lib/redis.js

      import { createClient } from "redis";

// Set these environment variables in apphosting.yaml
const REDISHOST = process.env.REDISHOST;
const REDISPORT = process.env.REDISPORT;

let redisClient;

export async function getClient(req, res) {
  // Only connect if a connection isn't already available
  if (!redisClient) {
    redisClient = await createClient(REDISPORT, REDISHOST)
      .on("error", (err) => console.error("Redis Client Error", err))
      .connect();
  }

  return redisClient;
}

    • src/app/counter/route.js

      import { getClient } from "@/lib/redis.js";

export async function GET(request) {
  const redisClient = await getClient();
  const count = await redisClient.get("counter");

  return Response.json({ count });
}

export async function POST(request) {
  const redisClient = await getClient();
  const count = await redisClient.incr("counter");

  return Response.json({ count });
}

Étape 4 (facultatif): Configurer votre application pour le développement local

L'émulateur Firebase App Hosting peut remplacer les valeurs à l'aide de apphosting.emulator.yaml. Ici, vous pouvez modifier la valeur de REDISHOST pour qu'elle pointe vers le localhost afin de pouvoir développer en local à l'aide d'une installation locale de Redis.

  1. Installer Redis sur votre machine locale

  2. Créez ou modifiez apphosting.emulators.yaml pour faire référence à votre instance locale:

    env:
  - variable: REDISHOST
    value: 127.0.0.1