Connecter Firebase App Hosting à un réseau VPC

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

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

Choisir comment se connecter à un réseau VPC

  • Sortie VPC directe: plus simple, plus rapide et moins coûteuse. Utilise une adresse IP par conteneur. Recommandé pour la plupart des cas d'utilisation.
  • Connecteurs sans serveur: met en commun les adresses IP pour les applications plus volumineuses. Nécessite un paiement pour la VM sous-jacente. Pour en savoir plus sur les tarifs, consultez la section "Accès au VPC sans serveur" de la page Tarifs de VPC.

Configurer dans apphosting.yaml

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

Configuration de la sortie VPC directe (apphosting.yaml) :

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

Configuration du connecteur sans serveur (apphosting.yaml) :

runConfig:
  vpcAccess:
    egress: ALL_TRAFFIC
    connector: connector-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 Google Cloud projet que votre Firebase App Hosting backend et comment vous y connecter à l'aide de la sortie 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 De base 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.
    • Sélectionnez la région de votre backend App Hosting dans le sélecteur Région. Veillez à définir cette valeur pour qu'elle corresponde à la région de votre backend.
    • Sélectionnez n'importe quelle 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 Par défaut dans le sélecteur Réseau autorisé.

Étape 1 : Mettre à jour apphosting.yaml avec l'ID de votre réseau VPC

  1. Accédez à la page Réseaux VPC dans la Google Cloud console.
  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 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 : Ajouter des variables d'environnement qui dirigent votre application vers Redis

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

  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 Google Cloud console :

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

Étape 3 : Utiliser Redis à partir de 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 routes 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 (facultative) : Configurer votre application pour le développement local

L'Firebase App Hosting émulateur peut remplacer des valeurs à l'aide de apphosting.emulator.yaml. Vous pouvez y modifier la valeur de REDISHOST pour qu'elle pointe vers l'hôte local afin de pouvoir développer localement à l'aide d'une installation locale de Redis.

  1. Installer Redis sur votre ordinateur local

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

    env:
  - variable: REDISHOST
    value: 127.0.0.1