Configura il tuo ambiente


Spesso è necessaria una configurazione aggiuntiva per le funzioni, ad esempio chiavi API di terze parti o impostazioni modificabili. L'SDK Firebase per Cloud Functions offre una configurazione dell'ambiente integrata per semplificare l'archiviazione e il recupero di questo tipo di dati per il tuo progetto.

Puoi scegliere tra queste opzioni:

  • Configurazione parametrizzata (consigliata per la maggior parte degli scenari). Ciò fornisce una configurazione dell'ambiente fortemente tipizzata con parametri convalidati al momento del deployment, il che previene gli errori e semplifica il debug.
  • Configurazione basata su file delle variabili di ambiente. Con questo approccio, crei manualmente un file dotenv per caricare le variabili di ambiente.

Per la maggior parte dei casi d'uso, è consigliata la configurazione parametrizzata. Questo approccio rende disponibili i valori di configurazione sia in fase di runtime che di deployment e il deployment viene bloccato a meno che tutti i parametri non abbiano un valore valido. Al contrario, la configurazione con le variabili di ambiente non è disponibile al momento del deployment.

Configurazione con parametri

Cloud Functions for Firebase fornisce un'interfaccia per definire i parametri di configurazione in modo dichiarativo all'interno del codebase. Il valore di questi parametri è disponibile sia durante il deployment della funzione, quando si impostano le opzioni di deployment e runtime, sia durante l'esecuzione. Ciò significa che la CLI bloccherà il deployment a meno che tutti i parametri non abbiano un valore valido.

Per definire i parametri nel codice, segui questo modello:

const functions = require('firebase-functions/v1');
const { defineInt, defineString } = require('firebase-functions/params');

// Define some parameters
const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

Quando viene eseguito il deployment di una funzione con variabili di configurazione parametrizzate, l'interfaccia a riga di comando di Firebase tenta innanzitutto di caricare i relativi valori dai file .env locali. Se non sono presenti in questi file e non è impostato alcun default, la CLI chiederà i valori durante il deployment e li salverà automaticamente in un file .env denominato .env.<project_ID> nella directory functions/:

$ firebase deploy
i  functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i  functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i  functions: Loaded environment variables from .env.projectId

A seconda del flusso di lavoro di sviluppo, potrebbe essere utile aggiungere il file .env.<project_ID> generato al controllo della versione.

Utilizzo dei parametri nell'ambito globale

Durante il deployment, il codice delle funzioni viene caricato e ispezionato prima che i parametri abbiano valori effettivi. Ciò significa che il recupero dei valori dei parametri durante l'ambito globale comporta un errore di deployment. Per i casi in cui vuoi utilizzare un parametro per inizializzare un valore globale, utilizza il callback di inizializzazione onInit(). Questo callback viene eseguito prima di qualsiasi funzione in produzione, ma non viene chiamato durante il deployment, quindi è un luogo sicuro per accedere al valore di un parametro.

  const { GoogleGenerativeAI } = require('@google/generative-ai');
  const { defineSecret } = require('firebase-functions/params');
  const { onInit } = require('firebase-functions/v1');

  const apiKey = defineSecret('GOOGLE_API_KEY');

  let genAI;
  onInit(() => {
    genAI = new GoogleGenerativeAI(apiKey.value());
  })

Configurare il comportamento dell'interfaccia a riga di comando

I parametri possono essere configurati con un oggetto Options che controlla il modo in cui la CLI richiede i valori. L'esempio seguente imposta le opzioni per convalidare il formato di un numero di telefono, per fornire un'opzione di selezione semplice e per compilare automaticamente un'opzione di selezione dal progetto Firebase:

const { defineString } = require('firebase-functions/params');

const welcomeMessage = defineString('WELCOME_MESSAGE', {default: 'Hello World',
description: 'The greeting that is returned to the caller of this function'});

const onlyPhoneNumbers = defineString('PHONE_NUMBER', {input: {text:
{validationRegex: /\d{3}-\d{3}-\d{4}/, validationErrorMessage: "Please enter
a phone number in the format XXX-YYY-ZZZZ"}}});

const selectedOption = defineString('PARITY', {input: {select: {options:
[{value: "odd"}, {value: "even"}]}}})

const storageBucket = defineString('BUCKET', {input: {resource: {type:
"storage.googleapis.com/Bucket"}}, description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets"})

Tipi di parametri

La configurazione parametrizzata fornisce una tipizzazione forte per i valori dei parametri e supporta anche i secret di Cloud Secret Manager. I tipi supportati sono:

  • Secret
  • Stringa
  • Booleano
  • Numero intero
  • In virgola mobile

Valori ed espressioni dei parametri

Firebase valuta i parametri sia al momento del deployment sia durante l'esecuzione della funzione. A causa di questi due ambienti, è necessario prestare particolare attenzione quando si confrontano i valori dei parametri e quando li si utilizza per impostare le opzioni di runtime per le funzioni.

Per passare un parametro alla funzione come opzione di runtime, passalo direttamente:

const functions = require('firebase-functions/v1');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

Inoltre, se devi eseguire un confronto con un parametro per sapere quale opzione scegliere, devi utilizzare i comparatori integrati anziché controllare il valore:

const functions = require('firebase-functions/v1');
const { defineBool } = require('firebase-functions/params');
const environment = params.defineString(‘ENVIRONMENT’, {default: ‘dev’});

// use built-in comparators
const minInstancesConfig =environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

È possibile accedere ai parametri e alle espressioni di parametri utilizzati solo in fase di runtime con la funzione value:

const functions = require('firebase-functions/v1');
const { defineString } = require('firebase-functions/params');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.https.onRequest(
 (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

Parametri integrati

L'SDK Cloud Functions offre tre parametri predefiniti, disponibili dal sottopacchetto firebase-functions/params:

  • projectID: il progetto Cloud in cui è in esecuzione la funzione.
  • databaseURL: l'URL dell'istanza di Realtime Database associata alla funzione (se abilitata nel progetto Firebase).
  • storageBucket: il bucket Cloud Storage associato alla funzione (se abilitato nel progetto Firebase).

Queste funzioni sono simili ai parametri stringa definiti dall'utente in tutti gli aspetti, tranne per il fatto che, poiché i loro valori sono sempre noti alla CLI Firebase, non verrà mai richiesto di inserirli durante il deployment né salvati nei file .env.

Parametri secret

I parametri di tipo Secret, definiti utilizzando defineSecret(), rappresentano parametri stringa che hanno un valore archiviato in Cloud Secret Manager. Anziché eseguire il controllo rispetto a un file .env locale e scrivere un nuovo valore nel file se manca, i parametri secret vengono controllati rispetto all'esistenza in Cloud Secret Manager e viene richiesto in modo interattivo il valore di un nuovo secret durante il deployment.

I parametri segreti definiti in questo modo devono essere associati a singole funzioni che devono avere accesso:

const functions = require('firebase-functions/v1');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');

export const postToDiscord = functions.runWith({ secrets: [discordApiKey] }).https.onRequest(
  (req, res) => {
    const apiKey = discordApiKey.value();
    //…

Poiché i valori dei secret sono nascosti fino all'esecuzione della funzione, non puoi utilizzarli durante la configurazione della funzione.

Variabili di ambiente

Cloud Functions for Firebase supporta il formato file dotenv per caricare le variabili di ambiente specificate in un file .env nel runtime dell'applicazione. Una volta eseguito il deployment, le variabili di ambiente possono essere lette tramite l'interfaccia process.env.

Per configurare l'ambiente in questo modo, crea un file .env nel tuo progetto, aggiungi le variabili che preferisci ed esegui il deployment:

  1. Crea un file .env nella directory functions/:

    # Directory layout:
#   my-project/
#     firebase.json
#     functions/
#       .env
#       package.json
#       index.js

  2. Apri il file .env per modificarlo e aggiungi le chiavi che preferisci. Ad esempio:

    PLANET=Earth
AUDIENCE=Humans

  3. Esegui il deployment delle funzioni e verifica che le variabili di ambiente siano state caricate:

    firebase deploy --only functions
# ...
# i functions: Loaded environment variables from .env.
# ...

Una volta eseguito il deployment delle variabili di ambiente personalizzate, il codice della funzione può accedervi con la sintassi process.env:

// Responds with "Hello Earth and Humans"
exports.hello = functions.https.onRequest((request, response) => {
  response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});

Deployment di più set di variabili di ambiente

Se hai bisogno di un insieme alternativo di variabili di ambiente per i tuoi progetti Firebase (ad esempio gestione temporanea e produzione), crea un file .env.<project or alias> e scrivi lì le variabili di ambiente specifiche del progetto. Le variabili di ambiente dei file .env e .env specifici del progetto (se esistenti) saranno incluse in tutte le funzioni di cui è stato eseguito il deployment.

Ad esempio, un progetto potrebbe includere questi tre file contenenti valori leggermente diversi per lo sviluppo e la produzione:

.env .env.dev .env.prod
PLANET=Earth

AUDIENCE=Humans

AUDIENCE=Dev Humans AUDIENCE=Prod Humans

Dati i valori in questi file separati, l'insieme di variabili di ambiente di cui viene eseguito il deployment con le tue funzioni varia a seconda del progetto di destinazione:

$ firebase use dev
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.dev.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Dev Humans

$ firebase use prod
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.prod.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Prod Humans

Variabili di ambiente riservate

Alcune chiavi delle variabili di ambiente sono riservate per uso interno. Non utilizzare nessuna di queste chiavi nei file .env:

  • Tutte le chiavi che iniziano con X_GOOGLE_
  • Tutte le chiavi che iniziano con EXT_
  • Tutte le chiavi che iniziano con FIREBASE_
  • Qualsiasi tasto del seguente elenco:
  • CLOUD_RUNTIME_CONFIG
  • ENTRY_POINT
  • GCP_PROJECT
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • FUNCTION_TRIGGER_TYPE
  • FUNCTION_NAME
  • FUNCTION_MEMORY_MB
  • FUNCTION_TIMEOUT_SEC
  • FUNCTION_IDENTITY
  • FUNCTION_REGION
  • FUNCTION_TARGET
  • FUNCTION_SIGNATURE_TYPE
  • K_SERVICE
  • K_REVISION
  • PORT
  • K_CONFIGURATION

Archivia e accedi a informazioni di configurazione sensibili

Le variabili di ambiente archiviate nei file .env possono essere utilizzate per la configurazione delle funzioni, ma non devono essere considerate un modo sicuro per archiviare informazioni sensibili come le credenziali del database o le chiavi API. Ciò è particolarmente importante se inserisci i file .env nel controllo del codice sorgente.

Per aiutarti ad archiviare informazioni di configurazione sensibili, Cloud Functions for Firebase si integra con Google Cloud Secret Manager. Questo servizio criptato archivia in modo sicuro i valori di configurazione, consentendo comunque un facile accesso dalle funzioni quando necessario.

Creare e utilizzare un secret

Per creare un secret, utilizza la CLI Firebase.

Per creare e utilizzare un secret:

  1. Dalla directory principale del progetto locale, esegui questo comando: 

    firebase functions:secrets:set SECRET_NAME

  2. Inserisci un valore per SECRET_NAME.

    La CLI mostra un messaggio di conferma e avvisa che devi eseguire il deployment delle funzioni affinché la modifica abbia effetto.

  3. Prima del deployment, assicurati che il codice delle funzioni consenta alla funzione di accedere al secret utilizzando il parametro runWith:

    exports.processPayment = functions
  // Make the secret available to this function
  .runWith({ secrets: ["SECRET_NAME"] })
  .onCall((data, context) => {
    const myBillingService = initializeBillingService(
      // reference the secret value
      process.env.SECRET_NAME
    );
    // Process the payment
  });

  4. Esegui il deployment di Cloud Functions:

    firebase deploy --only functions

Ora potrai accedervi come a qualsiasi altra variabile di ambiente. Al contrario, se un'altra funzione che non specifica il secret in runWith tenta di accedere al secret, riceve un valore indefinito:

  exports.anotherEndpoint = functions.https.onRequest((request, response) => {
    response.send(`The secret API key is ${process.env.SECRET_NAME}`);
    // responds with "The secret API key is undefined" because the `runWith` parameter is missing
  });

Una volta eseguito il deployment della funzione, questa avrà accesso al valore del secret. Solo le funzioni che includono specificamente un secret nel parametro runWith avranno accesso a questo secret come variabile di ambiente. In questo modo, i valori dei secret sono disponibili solo dove sono necessari, riducendo il rischio di rivelare accidentalmente un secret.

Gestione dei secret

Utilizza la CLI Firebase per gestire i secret. Quando gestisci i secret in questo modo, tieni presente che alcune modifiche alla CLI richiedono di modificare e/o ridistribuire le funzioni associate. In particolare:

  • Ogni volta che imposti un nuovo valore per un secret, devi eseguire nuovamente il deployment di tutte le funzioni che fanno riferimento a quel secret affinché acquisiscano l'ultimo valore.
  • Se elimini un secret, assicurati che nessuna delle tue funzioni di cui è stato eseguito il deployment faccia riferimento a quel secret. Le funzioni che utilizzano un valore secret eliminato non verranno eseguite.

Ecco un riepilogo dei comandi dell'interfaccia a riga di comando Firebase per la gestione dei secret:

# Change the value of an existing secret
firebase functions:secrets:set SECRET_NAME

# View the value of a secret
functions:secrets:access SECRET_NAME

# Destroy a secret
functions:secrets:destroy SECRET_NAME

# View all secret versions and their state
functions:secrets:get SECRET_NAME

# Automatically clean up all secrets that aren't referenced by any of your functions
functions:secrets:prune

Per i comandi access e destroy, puoi fornire il parametro facoltativo della versione per gestire una versione specifica. Ad esempio:

functions:secrets:access SECRET_NAME[@VERSION]

Per ulteriori informazioni su queste operazioni, passa -h con il comando per visualizzare la guida della CLI.

Come vengono fatturati i secret

Secret Manager consente di avere 6 versioni di secret attive senza costi. Ciò significa che puoi avere 6 secret al mese in un progetto Firebase senza costi.

Per impostazione predefinita, la CLI Firebase tenta di eliminare automaticamente le versioni secret non utilizzate ove opportuno, ad esempio quando esegui il deployment di funzioni con una nuova versione del secret. Inoltre, puoi eliminare attivamente i secret inutilizzati utilizzando functions:secrets:destroy e functions:secrets:prune.

Secret Manager consente 10.000 operazioni di accesso mensili non fatturate a un secret. Le istanze di funzione leggono solo i secret specificati nel parametro runWith ogni volta che vengono avviate a freddo. Se hai molte istanze di funzioni che leggono molti secret, il tuo progetto potrebbe superare questa quota, a quel punto ti verranno addebitati 0,03 $per 10.000 operazioni di accesso.

Per ulteriori informazioni, vedi i prezzi di Secret Manager.

Supporto dell'emulatore

La configurazione dell'ambiente con dotenv è progettata per interagire con un emulatore Cloud Functions locale.

Quando utilizzi un emulatore locale di Cloud Functions, puoi sostituire le variabili di ambiente per il tuo progetto configurando un file .env.local. I contenuti di .env.local hanno la precedenza su .env e sul file .env specifico del progetto.

Ad esempio, un progetto potrebbe includere questi tre file contenenti valori leggermente diversi per lo sviluppo e i test locali:

.env .env.dev .env.local
PLANET=Earth

AUDIENCE=Humans

AUDIENCE=Dev Humans AUDIENCE=Local Humans

Quando viene avviato nel contesto locale, l'emulatore carica le variabili di ambiente come mostrato di seguito:

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

Credenziali e dati segreti nell'emulatore Cloud Functions

L'emulatore Cloud Functions supporta l'utilizzo dei secret per archiviare e accedere alle informazioni di configurazione sensibili. Per impostazione predefinita, l'emulatore tenterà di accedere ai secret di produzione utilizzando le credenziali predefinite dell'applicazione. In determinate situazioni, come gli ambienti CI, l'emulatore potrebbe non riuscire ad accedere ai valori dei secret a causa di limitazioni delle autorizzazioni.

Analogamente al supporto dell'emulatore Cloud Functions per le variabili di ambiente, puoi ignorare i valori dei secret configurando un file .secret.local. In questo modo, puoi testare facilmente le tue funzioni localmente, soprattutto se non hai accesso al valore del secret.

Migrazione dalla configurazione dell'ambiente

Se hai utilizzato la configurazione dell'ambiente con functions.config, devi eseguire la migrazione della configurazione esistente come variabili di ambiente (in formato dotenv) prima della fine del 2025, quando functions.config verrà ritirato. La CLI Firebase fornisce un comando di esportazione che restituisce la configurazione di ogni alias o progetto elencato nel file .firebaserc della directory (nell'esempio riportato di seguito, local, dev e prod) come file .env.

Per eseguire la migrazione, esporta le configurazioni dell'ambiente esistenti utilizzando il comando firebase functions:config:export:

firebase functions:config:export
i  Importing configs from projects: [project-0, project-1]
⚠  The following configs keys could not be exported as environment variables:

⚠  project-0 (dev):
    1foo.a => 1FOO\_A (Key 1FOO\_A must start with an uppercase ASCII letter or underscore, and then consist of uppercase ASCII letters, digits, and underscores.)

Enter a PREFIX to rename invalid environment variable keys: CONFIG\_
✔  Wrote functions/.env.prod
✔  Wrote functions/.env.dev
✔  Wrote functions/.env.local
✔  Wrote functions/.env

Tieni presente che, in alcuni casi, ti verrà chiesto di inserire un prefisso per rinominare le chiavi delle variabili di ambiente esportate. Questo perché non tutte le configurazioni possono essere trasformate automaticamente, in quanto potrebbero non essere valide o potrebbero essere una chiave di variabile di ambiente riservata.

Ti consigliamo di esaminare attentamente i contenuti dei file .env generati prima di eseguire il deployment delle funzioni o archiviare i file .env nel controllo del codice sorgente. Se alcuni valori sono sensibili e non devono essere divulgati, rimuovili dai file .env e archiviali in modo sicuro in Secret Manager.

Dovrai anche aggiornare il codice delle funzioni. Tutte le funzioni che utilizzano functions.config ora dovranno utilizzare process.env, come mostrato in Eseguire l'upgrade alla seconda generazione.

Configurazione dell'ambiente

Imposta la configurazione dell'ambiente con la CLI

Per archiviare i dati dell'ambiente, puoi utilizzare il comando firebase functions:config:set nella Firebase CLI. Ogni chiave può essere associata a uno spazio dei nomi utilizzando i punti per raggruppare le configurazioni correlate. Tieni presente che nelle chiavi sono accettati solo caratteri minuscoli; i caratteri maiuscoli non sono consentiti.

Ad esempio, per memorizzare l'ID client e la chiave API per "Some Service", puoi eseguire:

firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"

Recupera la configurazione dell'ambiente attuale

Per esaminare i contenuti attualmente archiviati nella configurazione dell'ambiente per il tuo progetto, puoi utilizzare firebase functions:config:get. L'output JSON sarà simile a questo:

{
  "someservice": {
    "key":"THE API KEY",
    "id":"THE CLIENT ID"
  }
}

Questa funzionalità si basa sull'Google CloudAPI Runtime Configuration.

Utilizza functions.config per accedere alla configurazione dell'ambiente in una funzione

Alcune configurazioni vengono fornite automaticamente nello spazio dei nomi riservato firebase. La configurazione dell'ambiente viene resa disponibile all'interno della funzione in esecuzione tramite functions.config(). Per utilizzare la configurazione precedente, il codice potrebbe avere il seguente aspetto:

const functions = require('firebase-functions/v1');
const request = require('request-promise');

exports.userCreated = functions.database.ref('/users/{id}').onWrite(event => {
  let email = event.data.child('email').val();

  return request({
    url: 'https://someservice.com/api/some/call',
    headers: {
      'X-Client-ID': functions.config().someservice.id,
      'Authorization': `Bearer ${functions.config().someservice.key}`
    },
    body: {email: email}
  });
});

Utilizza la configurazione dell'ambiente per inizializzare un modulo

Alcuni moduli Node sono pronti senza alcuna configurazione. Altri moduli richiedono una configurazione aggiuntiva per essere inizializzati correttamente. Ti consigliamo di archiviare questa configurazione in variabili di configurazione dell'ambiente anziché codificarla in modo permanente. In questo modo, il codice è molto più portatile, il che ti consente di aprire il codice sorgente dell'applicazione o passare facilmente dalla versione di produzione a quella di gestione temporanea.

Ad esempio, per utilizzare il modulo Slack Node SDK, puoi scrivere:

const functions = require('firebase-functions/v1');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);

Prima del deployment, imposta la variabile di configurazione dell'ambiente slack.url:

firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX

Comandi aggiuntivi per l'ambiente

  • firebase functions:config:unset key1 key2 rimuove le chiavi specificate dalla configurazione
  • firebase functions:config:clone --from <fromProject> clona l'ambiente di un altro progetto nel progetto attualmente attivo.

Variabili di ambiente compilate automaticamente

Esistono variabili di ambiente che vengono compilate automaticamente nel runtime delle funzioni e nelle funzioni emulate localmente. Queste includono quelle compilate da Google Cloud, nonché una variabile di ambiente specifica di Firebase:

process.env.FIREBASE_CONFIG: fornisce le seguenti informazioni di configurazione del progetto Firebase:

{
  databaseURL: 'https://DATABASE_NAME.firebaseio.com',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  projectId: 'PROJECT_ID'
}

Tieni presente che i valori nella configurazione Firebase effettiva potrebbero variare a seconda delle risorse di cui hai eseguito il provisioning nel progetto.

Questa configurazione viene applicata automaticamente quando inizializzi l'SDK Firebase Admin senza argomenti. Se scrivi funzioni in JavaScript, inizializza come segue:

const admin = require('firebase-admin');
admin.initializeApp();

Se scrivi funzioni in TypeScript, inizializza come segue:

import * as functions from 'firebase-functions/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
admin.initializeApp();

Se devi inizializzare l'SDK Admin con la configurazione del progetto predefinita utilizzando le credenziali del service account, puoi caricare le credenziali da un file e aggiungerle a FIREBASE_CONFIG nel seguente modo:

serviceAccount = require('./serviceAccount.json');

const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);