Usar a Configuração remota em ambientes de servidor


O Firebase Remote Config oferece suporte à configuração do lado do servidor usando o SDK Admin para Python do Firebase v6.7.0 ou mais recente. Com esse recurso, você pode gerenciar de forma dinâmica o comportamento e a configuração de aplicativos do lado do servidor usando Remote Config. Isso inclui implementações sem servidor, como Cloud Functions.

Ao contrário dos SDKs de cliente do Firebase, que buscam uma configuração específica do cliente derivada do modelo de Remote Config, o SDK Remote Config do servidor faz o download de um modelo de Remote Config completo do Firebase. Seu servidor pode avaliar o modelo com cada solicitação recebida e usar sua própria lógica para fornecer uma resposta personalizada com latência muito baixa. É possível usar condições para controlar e personalizar respostas com base em porcentagens aleatórias e atributos do cliente definidos em indicadores personalizados.

Com Remote Config do servidor, o seguinte é possível:

  • Definir parâmetros de configuração para aplicativos executados ou acessados pelo seu servidor, o que permite casos de uso como parâmetros e comandos do modelo de IA de configuração remota, além de outras integrações, para garantir que as chaves de API permanecem seguras.
  • Ajustar dinamicamente os parâmetros em resposta a mudanças no ambiente ou outras mudanças no aplicativo, como atualização de parâmetros LLM e endpoints de modelo.
  • Controlar os custos atualizando remotamente as APIs chamadas pelo servidor.
  • Gerar configurações personalizadas imediatamente para clientes que acessam seus servidor.
  • Registrar quais clientes receberam um valor de parâmetro e usar essas informações em Cloud Functions como parte de um sistema de verificação de direitos.

É possível implantar Remote Config do servidor no Cloud Run, Cloud Functions ou em ambientes de servidor auto-hospedados.

Antes de começar

Siga as instruções em Adicionar o SDK Admin do Firebase ao seu servidor para criar um projeto, configure uma conta de serviço e adicione o SDK Python do Firebase ao seu servidor.

Etapa 1: inicializar o SDK Admin para Python do Firebase e autorizar solicitações de API

Quando você inicializa o SDK Admin sem parâmetros, o SDK usa o Google Application Default Credentials e lê as opções da variável de ambiente GOOGLE_APPLICATION_CREDENTIALS. Para inicializar o SDK e adicionar Remote Config:

import firebase_admin
import asyncio
import json

firebase_admin.initialize_app()

Etapa 2: identificar os valores de parâmetros padrão do aplicativo do servidor

Identifique as variáveis do app que você quer usar para realizar a atualização dinâmica com Remote Config. Depois, considere quais variáveis precisam ser definidas por padrão no seu aplicativo e quais devem ser os valores padrão deles. Isso garante que o app seja executado, mesmo que a conexão com o servidor de back-end de Remote Config seja interrompida.

Por exemplo, se você estiver gravando um aplicativo de servidor que gerencia uma função de IA generativa, é possível definir um nome de modelo padrão, preâmbulo do comando e uma configuração de IA generativa, como esta:

Nome do parâmetro Descrição Tipo Valor padrão
model_name Nome da API do modelo String gemini-2.0-flash
preamble_prompt Comando para adição ao início da consulta do usuário String I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!
generation_config Parâmetros a serem enviados ao modelo JSON {"stopSequences": ["I hope this helps"], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}

Etapa 3: configurar o aplicativo de servidor

Depois de determinar os parâmetros que você quer usar com Remote Config, configure o app para definir valores padrão, buscar o modelo de Remote Config específico do servidor e usar os valores dele. As etapas a seguir descrevem como configurar seu aplicativo Python.

  1. Acesse e carregue o modelo.

    from firebase_admin import remote_config

# Initialize server-side Remote Config
template = remote_config.init_server_template()

# Load the template from the backend
 asyncio.run(template.load())

    Se você estiver usando o Python com Cloud Functions, poderá usar o get_server_template assíncrono para buscar e carregar o modelo em uma única etapa:

    # Initialize server-side Remote Config
template = remote_config.get_server_template()

  2. Para garantir que o app seja executado, mesmo que a conexão com o servidor de back-end de Remote Config seja interrompida, adicione a ele valores padrão para cada parâmetro. Para isso, adicione um defaultConfig à função de modelo init_server_template ou get_server_template:

    template = remote_config.init_server_template({
  defaultConfig: {
    'model_name': "gemini-pro",
    'generation_config': '{"stopSequences": [], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}',
    'preamble_prompt': "I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!"
  },
})

# Load Remote Config
asyncio.run(template.load())

    Outra maneira de inicializar um modelo é usando a função get_server_template para recuperar o modelo de servidor necessário. É possível converter esse modelo em um formato JSON usando a função template.to_json. Esse modelo JSON pode ser armazenado localmente. Em seguida, é possível inicializar esse modelo JSON usando a função init_server_template.

  3. Depois que o modelo for carregado, use template.evaluate() para importar parâmetros e valores do modelo:

    # Add template parameters to config
config = template.evaluate()

  4. Se você definir condições no modelo de Remote Config, também será possível definir e especificar os valores que você quer:

    • Ao usar condições percentuais, adicione o randomizationId que você quer usar para avaliar as condições à função template.evaluate().
    • Ao usar indicadores personalizados, defina os atributos e os valores deles. Os indicadores personalizados estão disponíveis com o SDK Admin para Python do Firebase v6.7.0 e versões mais recentes.

    Por exemplo, você pode definir um ID de instalação do Firebase como randomizationId ou um ID do usuário para garantir que cada usuário que entre em contato com o servidor seja adicionado ao grupo aleatório adequado, version como um indicador personalizado para segmentar versões específicas do cliente e platform como um indicador personalizado para segmentar a plataforma do cliente.

    Para mais informações sobre condições, consulte Tipos de regra de condição.

    # Add template parameters to `config`. Evaluates the
# template and returns the parameter value assigned to
# the group assigned to the {randomizationId} and version.
config = template.evaluate({
  'randomizationId': "2ac93c28-c459-4760-963d-a3974ec26c04",
  'version': "1.0",
  'platform': "Android"
})

  5. Em seguida, extraia os valores de parâmetro necessários da constante de configuração. Use getters para converter os valores de Remote Config no formato esperado. Confira os seguintes tipos compatíveis:

    • Booleano: get_bool
    • Objeto: get_value
    • Número: get_number
    • String: get_string

    Por exemplo, se você estiver implementando a Vertex AI no seu servidor e quiser alterar o modelo e os parâmetros dele, talvez seja melhor configurar os parâmetros para model_name e generation_config. Confira um exemplo de como acessar os valores de Remote Config:

    # Replace defaults with values from Remote Config.
generation_config = json.loads(config.get_string('generation_config'))
is_ai_enabled = config.get_bool('is_ai_enabled')
model = config.get_string('model_name')

# Generates a prompt comprised of the Remote Config
# parameter and prepends it to the user prompt.
prompt = f"{config.get_string('preamble_prompt')}{req.args.get('prompt')}"

  6. Se o servidor for de longa duração, ao contrário de um ambiente sem servidor, use setInterval para atualizar periodicamente o modelo e garantir que você está buscando periodicamente o modelo mais atualizado do servidor de Remote Config.

Etapa 4: definir valores de parâmetros específicos do servidor em Remote Config

Em seguida, crie um modelo de Remote Config do servidor e configure os parâmetros e os valores para uso no app.

Para criar um modelo de Remote Config específico do servidor:

  1. Abra a página de parâmetros de Remote Config no console do Firebase e, no seletor Cliente/servidor, selecione Servidor.
  2. Defina os parâmetros de Remote Config com os mesmos nomes e tipos de dados que os parâmetros definidos no app e envie valores. Esses valores vão substituir o defaultConfig definido em Configurar o app do servidor quando você buscar e avaliar o modelo e atribuir esses valores às variáveis.
  3. Também é possível definir condições para aplicar persistentemente valores a uma amostra aleatória de instâncias ou indicadores personalizados definidos por você. Para mais informações sobre as condições, consulte Tipos de regra de condição.
  4. Quando terminar de adicionar parâmetros, clique em Publicar alterações.
  5. Revise as alterações e clique em Publicar alterações novamente.

Etapa 5: implantar com Cloud Functions ou o Cloud Run

Se o app do servidor for leve e orientado por eventos, considere implantar o código usando Cloud Functions. Por exemplo, imagine que você tem um app que inclui diálogos entre personagens desenvolvidos com uma API de IA generativa (por exemplo, Google AI ou Vertex AI). Nesse caso, é possível hospedar a lógica de veiculação do LLM em uma função que o app chama sob demanda.

Se seu aplicativo for projetado para ser de longa duração (por exemplo, um aplicativo da Web com recursos), considere o Cloud Run. Para implantar seu app de servidor com o Cloud Run, siga o guia em Guia de início rápido: implantar um serviço Python para o Cloud Run.

Para mais informações sobre os melhores casos de uso do Cloud Run e de Cloud Functions, consulte Cloud Functions x Cloud Run: quando usar um em vez do outro.