Conectar o Firebase App Hosting a uma rede VPC

Seu back-end Firebase App Hosting pode se conectar a uma rede de nuvem privada virtual (VPC). Isso permite que seu backend Firebase App Hosting acesse serviços de back-end que não podem ser acessados usando endereços IP públicos, como Cloud SQL, Spanner, Cloud Memorystore, Compute Engine ou microsserviços internos do Kubernetes.

O acesso à VPC está disponível apenas no tempo de execução (do contêiner Cloud Run), não no tempo de build (Cloud Build).

Escolher como se conectar a uma rede VPC

  • VPC direta: mais simples, rápida e barata. Usa um endereço IP por contêiner. Recomendado para a maioria dos casos de uso.
  • Conectores sem servidor: agrupa endereços IP para aplicativos maiores. Exige o pagamento da VM subjacente. Consulte "Acesso VPC sem servidor" na página de preços da VPC para mais detalhes.

Configurar em apphosting.yaml

Use o mapeamento vpcAccess no arquivo apphosting.yaml para configurar o acesso. Use um nome ou ID de rede/conector totalmente qualificado. O uso de IDs permite a portabilidade entre ambientes de teste e produção com diferentes conectores/redes.

Configuração de saída de VPC direta (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

Configuração do conector sem servidor (apphosting.yaml):

runConfig:
  vpcAccess:
    egress: ALL_TRAFFIC
    connector: connector-id

Exemplo: conectar-se ao Memorystore para Redis de um app Next.js

Sistemas de armazenamento em cache, como Redis ou Memcached, são usados com frequência para criar uma camada de armazenamento em cache de dados rápida para um app. Este exemplo mostra como configurar o Memorystore para Redis no mesmo projeto Google Cloud que o back-end Firebase App Hosting e se conectar a ele usando o egresso direto da VPC.

Etapa 0: criar uma instância do Memorystore para Redis

  1. Acesse a página da Memorystore para Redis no console do Google Cloud.
    • Verifique se o mesmo projeto que você está usando para Firebase App Hosting está selecionado.
    • Se você não conseguir acessar essa página, verifique se o faturamento está ativado no seu projeto e se você ativou a API Memorystore.
  2. Selecione Criar instância.
  3. Configure a nova instância com as configurações que preferir. Confira alguns exemplos de valores que você pode usar:
    • Insira my-redis-cache em ID da instância.
    • Digite Redis cache em Nome de exibição.
    • Escolha Básico no seletor de nível. O nível básico designa um nó do Redis independente, ao contrário do nível padrão, que usa um nó de réplica para fazer backup dos dados.
    • Escolha a região do back-end do App Hosting no seletor Região. Defina esse valor para corresponder à região do seu back-end.
    • Escolha qualquer no seletor de zona.
    • Digite 5 em Capacidade. Isso define a capacidade da instância para 5 GB.
    • Selecione 5.0 em Versão (recomendado).
    • Escolha padrão no seletor Rede autorizada.

Etapa 1: atualize apphosting.yaml com o ID da rede VPC

  1. Acesse a página "Redes VPC" no console do Google Cloud.
  2. Encontre o ID da rede VPC da sua instância do Memorystore para Redis (geralmente default).

  3. Defina a configuração de saída da VPC direta em apphosting.yaml usando o ID da rede da VPC:

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

Etapa 2: adicionar variáveis de ambiente que direcionam seu app ao Redis

  1. Encontre as informações de conexão (host e porta) na guia "Conexões" da sua instância do Memorystore para Redis no console do Google Cloud.

  2. Conecte-se ao Redis com as variáveis de ambiente REDISPORT e REDISHOST. Defina esses valores em apphosting.yaml usando o host e a porta do console Google Cloud:

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

Etapa 3: usar o Redis no app

  1. Instale o pacote npm redis:

    npm install redis@latest

  2. Acesse o cache do Redis no seu código. Use as variáveis de ambiente configuradas na etapa anterior. Por exemplo, veja como ler de um cache em um gerenciador de rotas do 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 });
}

Etapa 4 (opcional): configurar o app para desenvolvimento local

O emulador Firebase App Hosting pode substituir valores usando apphosting.emulator.yaml. Aqui, você pode mudar o valor de REDISHOST para apontar para o host local e desenvolver localmente usando uma instalação local do Redis.

  1. Instale o Redis na sua máquina local

  2. Crie ou edite apphosting.emulators.yaml para referenciar sua instância local:

    env:
  - variable: REDISHOST
    value: 127.0.0.1