Autenticazione con il multitenancy

Questo documento mostra come autenticare gli utenti in un ambiente Identity Platform multi-tenant.

Prima di iniziare

Assicurati di aver attivato la multitenancy per il progetto e di aver configurato i tenant. Per scoprire come, consulta la sezione Introduzione all'architettura multi-tenancy.

Dovrai anche aggiungere l'SDK client alla tua app:

  1. Vai alla pagina Identity Platform nella console Google Cloud.
    Vai alla pagina degli utenti di Identity Platform

  2. In alto a destra, fai clic su Dettagli di configurazione dell'applicazione.

  3. Copia il codice nella tua app web. Ad esempio:

Versione web 9

import { initializeApp } from "firebase/app";

const firebaseConfig = {
  apiKey: "...",
  // By default, authDomain is '[YOUR_APP].firebaseapp.com'.
  // You may replace it with a custom domain.
  authDomain: '[YOUR_CUSTOM_DOMAIN]'
};
const firebaseApp = initializeApp(firebaseConfig);
auth_init_custom_domain.js

Versione web 8

firebase.initializeApp({
  apiKey: '...',
  // By default, authDomain is '[YOUR_APP].firebaseapp.com'.
  // You may replace it with a custom domain.
  authDomain: '[YOUR_CUSTOM_DOMAIN]'
});
index.js

Accedere con i tenant

Per accedere a un tenant, l'ID tenant deve essere passato all'oggetto auth. Tieni presente che tenantId non viene mantenuto durante i ricaricamenti della pagina.

Versione web 9

import { getAuth } from "firebase/auth";
const auth = getAuth();
const tenantId = "TENANT_ID1";
auth.tenantId = tenantId;
multitenant_set_tenant.js

Versione web 8

const tenantId = "TENANT_ID1";
firebase.auth().tenantId = tenantId;
multi-tenancy.js

Eventuali richieste di accesso future da questa istanza auth includeranno l'ID tenant (TENANT_ID1 nell'esempio precedente) finché non modifichi o reimposti l'ID tenant.

Puoi lavorare con più tenant utilizzando una o più istanze auth.

Per utilizzare una singola istanza di auth, modifica la proprietà tenantId ogni volta che vuoi passare da un tenant all'altro. Per ripristinare le IdP a livello di progetto, imposta tenantId su null:

Versione web 9

// One Auth instance
// Switch to tenant1
auth.tenantId = "TENANT_ID1";
// Switch to tenant2
auth.tenantId = "TENANT_ID2";
// Switch back to project level IdPs
auth.tenantId = null;
multitenant_switch_tenant.js

Versione web 8

// One Auth instance
// Switch to tenant1
firebase.auth().tenantId = "TENANT_ID1";
// Switch to tenant2
firebase.auth().tenantId = "TENANT_ID2";
// Switch back to project level IdPs
firebase.auth().tenantId = null;
multi-tenancy.js

Per utilizzare più istanze, crea una nuova istanza auth per ogni tenant e assegnati ID diversi:

Versione web 9

// Multiple Auth instances
import { initializeApp } from "firebase/app";
import { getAuth } from "firebase/auth";
const firebaseApp1 = initializeApp(firebaseConfig1, 'app1_for_tenantId1');
const firebaseApp2 = initializeApp(firebaseConfig2, 'app2_for_tenantId2');

const auth1 = getAuth(firebaseApp1);
const auth2 = getAuth(firebaseApp2);

auth1.tenantId = "TENANT_ID1";
auth2.tenantId = "TENANT_ID2";
multitenant_switch_tenant_multiinstance.js

Versione web 8

// Multiple Auth instances
firebase.initializeApp(config, 'app1_for_tenantId1');
firebase.initializeApp(config, 'app2_for_tenantId2');

const auth1 = firebase.app('app1').auth();
const auth2 = firebase.app('app2').auth();

auth1.tenantId = "TENANT_ID1";
auth2.tenantId = "TENANT_ID2";
multi-tenancy.js

Dopo aver eseguito l'accesso con un tenant, verrà restituito un utente del tenant con user.tenantId impostato su quel tenant. Tieni presente che se attivi tenantId in un secondo momento nell'istanza auth, la proprietà currentUser non cambierà, ma continuerà a puntare allo stesso utente del tenant precedente.

Versione web 9

import { signInWithEmailAndPassword, onAuthStateChanged } from "firebase/auth";
// Switch to TENANT_ID1
auth.tenantId = 'TENANT_ID1';

// Sign in with tenant
signInWithEmailAndPassword(auth, email, password)
  .then((userCredential) => {
    // User is signed in.
    const user = userCredential.user;
    // user.tenantId is set to 'TENANT_ID1'.
    // Switch to 'TENANT_ID2'.
    auth.tenantId = 'TENANT_ID2';
    // auth.currentUser still points to the user.
    // auth.currentUser.tenantId is 'TENANT_ID1'.
  });

// You could also get the current user from Auth state observer.
onAuthStateChanged(auth, (user) => {
  if (user) {
    // User is signed in.
    // user.tenantId is set to 'TENANT_ID1'.
  } else {
    // No user is signed in.
  }
});
multitenant_signin_password_demo.js

Versione web 8

// Switch to TENANT_ID1
firebase.auth().tenantId = 'TENANT_ID1';

// Sign in with tenant
firebase.auth().signInWithEmailAndPassword(email, password)
  .then((result) => {
    const user = result.user;
    // user.tenantId is set to 'TENANT_ID1'.
    // Switch to 'TENANT_ID2'.
    firebase.auth().tenantId = 'TENANT_ID2';
    // firebase.auth().currentUser still point to the user.
    // firebase.auth().currentUser.tenantId is 'TENANT_ID1'.
  });

// You could also get the current user from Auth state observer.
firebase.auth().onAuthStateChanged((user) => {
  if (user) {
    // User is signed in.
    // user.tenantId is set to 'TENANT_ID1'.
  } else {
    // No user is signed in.
  }
});
multi-tenancy.js

Account email/password

L'esempio seguente mostra come registrare un nuovo utente:

Versione web 9

import { createUserWithEmailAndPassword } from "firebase/auth";
auth.tenantId = 'TENANT_ID';

createUserWithEmailAndPassword(auth, email, password)
  .then((userCredential) => {
    // User is signed in.
    // userCredential.user.tenantId is 'TENANT_ID'.
  }).catch((error) => {
    // Handle / display error.
    // ...
  });
multitenant_signup_password.js

Versione web 8

firebase.auth().tenantId = 'TENANT_ID';

firebase.auth().createUserWithEmailAndPassword(email, password)
  .then((result) => {
    // result.user.tenantId is 'TENANT_ID'.
  }).catch((error) => {
    // Handle error.
  });
multi-tenancy.js

Per accedere con un utente esistente:

Versione web 9

import { signInWithEmailAndPassword } from "firebase/auth";
auth.tenantId = 'TENANT_ID';

signInWithEmailAndPassword(auth, email, password)
  .then((userCredential) => {
    // User is signed in.
    // userCredential.user.tenantId is 'TENANT_ID'.
  }).catch((error) => {
    // Handle / display error.
    // ...
  });
multitenant_signin_password.js

Versione web 8

firebase.auth().tenantId = 'TENANT_ID';

firebase.auth().signInWithEmailAndPassword(email, password)
  .then((result) => {
    // result.user.tenantId is 'TENANT_ID'.
  }).catch((error) => {
    // Handle error.
  });
multi-tenancy.js

SAML

Per accedere con un provider SAML, esegui l'inizializzazione di un'istanza SAMLAuthProvider con l'ID provider dalla console Google Cloud:

Versione web 9

import { SAMLAuthProvider } from "firebase/auth";

const provider = new SAMLAuthProvider("saml.myProvider");
auth_saml_provider_create.js

Versione web 8

const provider = new firebase.auth.SAMLAuthProvider('saml.myProvider');
saml.js

Puoi quindi utilizzare un popup o un flusso di reindirizzamento per accedere al fornitore di servizi SAML.

  • Popup

    Versione web 9

    import { signInWithPopup } from "firebase/auth";
// Switch to TENANT_ID1.
auth.tenantId = 'TENANT_ID1';

// Sign-in with popup.
signInWithPopup(auth, provider)
  .then((userCredential) => {
    // User is signed in.
    const user = userCredential.user;
    // user.tenantId is set to 'TENANT_ID1'.
    // Provider data available from the result.user.getIdToken()
    // or from result.user.providerData
  })
  .catch((error) => {
    // Handle / display error.
    // ...
  });
    multitenant_signin_saml_popup.js

    Versione web 8

    // Switch to TENANT_ID1.
firebase.auth().tenantId = 'TENANT_ID1';

// Sign-in with popup.
firebase.auth().signInWithPopup(provider)
  .then((result) => {
    // User is signed in.
    // tenant ID is available in result.user.tenantId.
    // Identity provider data is available in result.additionalUserInfo.profile.
  })
  .catch((error) => {
    // Handle error.
  });
    multi-tenancy.js

  • Reindirizzamento

    Versione web 9

    import { signInWithRedirect, getRedirectResult } from "firebase/auth";
// Switch to TENANT_ID1.
auth.tenantId = 'TENANT_ID1';

// Sign-in with redirect.
signInWithRedirect(auth, provider);

// After the user completes sign-in and returns to the app, you can get
// the sign-in result by calling getRedirectResult. However, if they sign out
// and sign in again with an IdP, no tenant is used.
getRedirectResult(auth)
  .then((result) => {
    // User is signed in.
    // The tenant ID available in result.user.tenantId.
    // Provider data available from the result.user.getIdToken()
    // or from result.user.providerData
  })
  .catch((error) => {
    // Handle / display error.
    // ...
  });
    multitenant_signin_saml_redirect.js

    Versione web 8

    // Switch to TENANT_ID1.
firebase.auth().tenantId = 'TENANT_ID1';

// Sign-in with redirect.
firebase.auth().signInWithRedirect(provider);

// After the user completes sign-in and returns to the app, you can get
// the sign-in result by calling getRedirectResult. However, if they sign out
// and sign in again with an IdP, no tenant is used.
firebase.auth().getRedirectResult()
  .then((result) => {
    // User is signed in.
    // The tenant ID available in result.user.tenantId.
    // Identity provider data is available in result.additionalUserInfo.profile.
  })
  .catch((error) => {
    // Handle error.
  });
    multi-tenancy.js

In entrambi i casi, assicurati di impostare l'ID tenant corretto sull'istanza auth.

Per avviare il flusso di autenticazione, mostra un'interfaccia che chiede all'utente di fornire il proprio indirizzo email, quindi chiama sendSignInLinkToEmail per inviargli un link di autenticazione. Assicurati di impostare l'ID tenant corretto sull'istanza auth prima di inviare l'email.

Versione web 9

import { sendSignInLinkToEmail } from "firebase/auth";
// Switch to TENANT_ID1
auth.tenantId = 'TENANT_ID1';

sendSignInLinkToEmail(auth, email, actionCodeSettings)
  .then(() => {
    // The link was successfully sent. Inform the user.
    // Save the email locally so you don't need to ask the user for it again
    // if they open the link on the same device.
    window.localStorage.setItem('emailForSignIn', email);
  })
  .catch((error) => {
    // Handle / display error.
    // ...
  });
multitenant_send_emaillink.js

Versione web 8

// Switch to TENANT_ID1
firebase.auth().tenantId = 'TENANT_ID1';

firebase.auth().sendSignInLinkToEmail(email, actionCodeSettings)
  .then(() => {
    // The link was successfully sent. Inform the user.
    // Save the email locally so you don't need to ask the user for it again
    // if they open the link on the same device.
    window.localStorage.setItem('emailForSignIn', email);
  })
  .catch((error) => {
    // Some error occurred, you can inspect the code: error.code
  });
multi-tenancy.js

Per completare l'accesso nella pagina di destinazione, analizza prima l'ID tenant dal link email e impostalo nell'istanza auth. Quindi, chiama signInWithEmailLink con l'indirizzo email dell'utente e il link email effettivo contenente il codice una tantum.

Versione web 9

import { isSignInWithEmailLink, parseActionCodeURL, signInWithEmailLink } from "firebase/auth";
if (isSignInWithEmailLink(auth, window.location.href)) {
  const actionCodeUrl = parseActionCodeURL(window.location.href);
  if (actionCodeUrl.tenantId) {
    auth.tenantId = actionCodeUrl.tenantId;
  }
  let email = window.localStorage.getItem('emailForSignIn');
  if (!email) {
    // User opened the link on a different device. To prevent session fixation
    // attacks, ask the user to provide the associated email again. For example:
    email = window.prompt('Please provide your email for confirmation');
  }
  // The client SDK will parse the code from the link for you.
  signInWithEmailLink(auth, email, window.location.href)
    .then((result) => {
      // User is signed in.
      // tenant ID available in result.user.tenantId.
      // Clear email from storage.
      window.localStorage.removeItem('emailForSignIn');
    });
}
multitenant_signin_emaillink.js

Versione web 8

if (firebase.auth().isSignInWithEmailLink(window.location.href)) {
  const actionCodeUrl = firebase.auth.ActionCodeURL.parseLink(window.location.href);
  if (actionCodeUrl.tenantId) {
    firebase.auth().tenantId = actionCodeUrl.tenantId;
  }
  let email = window.localStorage.getItem('emailForSignIn');
  if (!email) {
    // User opened the link on a different device. To prevent session fixation
    // attacks, ask the user to provide the associated email again. For example:
    email = window.prompt('Please provide your email for confirmation');
  }
  firebase.auth().signInWithEmailLink(email, window.location.href)
    .then((result) => {
      // User is signed in.
      // tenant ID available in result.user.tenantId.
    });
}
multi-tenancy.js

Creazione di token personalizzati

La creazione di un token personalizzato multi-tenant è identica alla creazione di un normale token personalizzato. Se nell'istanza auth è stato impostato l'ID tenant corretto, al JWT risultante verrà aggiunto un'affermazione tenant_id di primo livello. Consulta la sezione Creare token personalizzati per istruzioni dettagliate su come creare e utilizzare i token personalizzati.

L'esempio seguente mostra come creare un token personalizzato utilizzando l'SDK Admin:

Versione web 9

// Ensure you're using a tenant-aware auth instance
const tenantManager = admin.auth().tenantManager();
const tenantAuth = tenantManager.authForTenant('TENANT_ID1');

// Create a custom token in the usual manner
tenantAuth.createCustomToken(uid)
  .then((customToken) => {
    // Send token back to client
  })
  .catch((error) => {
    console.log('Error creating custom token:', error);
  });
multitenant_create_custom_token.js

Versione web 8

// Ensure you're using a tenant-aware auth instance
const tenantManager = admin.auth().tenantManager();
const tenantAuth = tenantManager.authForTenant('TENANT_ID1');

// Create a custom token in the usual manner
tenantAuth.createCustomToken(uid)
  .then((customToken) => {
    // Send token back to client
  })
  .catch((error) => {
    console.log('Error creating custom token:', error);
  });
multi-tenancy.js

Il seguente codice mostra come accedere utilizzando un token personalizzato:

Versione web 9

import { signInWithCustomToken } from "firebase/auth";
auth.tenantId = 'TENANT_ID1';

signInWithCustomToken(auth, token)
  .catch((error) => {
    // Handle / display error.
    // ...
  });
multitenant_signin_custom_token.js

Versione web 8

firebase.auth().tenantId = 'TENANT_ID1';

firebase.auth().signInWithCustomToken(token)
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // ...
  });
multi-tenancy.js

Tieni presente che se gli ID tenant non corrispondono, il metodo signInWithCustomToken() non andrà a buon fine.

Collegamento delle credenziali utente multi-tenant

Puoi collegare altri tipi di credenziali a un utente multi-tenant esistente. Ad esempio, se un utente si è autenticato in precedenza con un provider SAML in un tenant, puoi aggiungere l'accesso tramite email/password al suo account esistente in modo che possa utilizzare entrambi i metodi per accedere al tenant.

Versione web 9

import { signInWithPopup, EmailAuthProvider, linkWithCredential, SAMLAuthProvider, signInWithCredential } from "firebase/auth";
// Switch to TENANT_ID1
auth.tenantId = 'TENANT_ID1';

// Sign-in with popup
signInWithPopup(auth, provider)
  .then((userCredential) => {
    // Existing user with e.g. SAML provider.
    const prevUser = userCredential.user;
    const emailCredential =
      EmailAuthProvider.credential(email, password);
    return linkWithCredential(prevUser, emailCredential)
      .then((linkResult) => {
        // Sign in with the newly linked credential
        const linkCredential = SAMLAuthProvider.credentialFromResult(linkResult);
        return signInWithCredential(auth, linkCredential);
      })
      .then((signInResult) => {
        // Handle sign in of merged user
        // ...
      });
  })
  .catch((error) => {
    // Handle / display error.
    // ...
  });
multitenant_account_linking.js

Versione web 8

// Switch to TENANT_ID1
firebase.auth().tenantId = 'TENANT_ID1';

// Sign-in with popup
firebase.auth().signInWithPopup(provider)
  .then((result) => {
    // Existing user with e.g. SAML provider.
    const user = result.user;
    const emailCredential =
      firebase.auth.EmailAuthProvider.credential(email, password);
    return user.linkWithCredential(emailCredential);
  })
  .then((linkResult) => {
    // The user can sign in with both SAML and email/password now.
  });
multi-tenancy.js

Quando colleghi o autentica di nuovo un utente multi-tenant esistente,auth.tenantId verrà ignorato; utilizza user.tenantId per specificare il tenant da utilizzare. Questo vale anche per altre API di gestione degli utenti, come updateProfile e updatePassword.

Gestione degli errori account-exists-with-different-credential

Se hai attivato l'impostazione Collega gli account che utilizzano lo stesso indirizzo email nella console Google Cloud, quando un utente tenta di accedere a un provider (ad esempio SAML) con un indirizzo email già esistente per un altro provider (ad esempio Google), viene generato l'errore auth/account-exists-with-different-credential (insieme a un oggetto AuthCredential).

Per completare l'accesso con il provider previsto, l'utente deve prima accedere al provider esistente (Google), quindi eseguire il collegamento all'AuthCredential precedente (SAML).

Per gestire questo errore, puoi utilizzare un popup o un flusso di reindirizzamento.

  • Popup

    Versione web 9

    import { signInWithPopup, fetchSignInMethodsForEmail, linkWithCredential } from "firebase/auth";
// Step 1.
// User tries to sign in to the SAML provider in that tenant.
auth.tenantId = 'TENANT_ID';
signInWithPopup(auth, samlProvider)
  .catch((error) => {
    // An error happened.
    if (error.code === 'auth/account-exists-with-different-credential') {
      // Step 2.
      // User's email already exists.
      // The pending SAML credential.
      const pendingCred = error.credential;
      // The credential's tenantId if needed: error.tenantId
      // The provider account's email address.
      const email = error.customData.email;
      // Get sign-in methods for this email.
      fetchSignInMethodsForEmail(email, auth)
        .then((methods) => {
          // Step 3.
          // Ask the user to sign in with existing Google account.
          if (methods[0] == 'google.com') {
            signInWithPopup(auth, googleProvider)
              .then((result) => {
                // Step 4
                // Link the SAML AuthCredential to the existing user.
                linkWithCredential(result.user, pendingCred)
                  .then((linkResult) => {
                    // SAML account successfully linked to the existing
                    // user.
                    goToApp();
                  });
              });
          }
        });
    }
  });
    multitenant_account_exists_popup.js

    Versione web 8

    // Step 1.
// User tries to sign in to the SAML provider in that tenant.
firebase.auth().tenantId = 'TENANT_ID';
firebase.auth().signInWithPopup(samlProvider)
  .catch((error) => {
    // An error happened.
    if (error.code === 'auth/account-exists-with-different-credential') {
      // Step 2.
      // User's email already exists.
      // The pending SAML credential.
      const pendingCred = error.credential;
      // The credential's tenantId if needed: error.tenantId
      // The provider account's email address.
      const email = error.email;
      // Get sign-in methods for this email.
      firebase.auth().fetchSignInMethodsForEmail(email)
        .then((methods) => {
          // Step 3.
          // Ask the user to sign in with existing Google account.
          if (methods[0] == 'google.com') {
            firebase.auth().signInWithPopup(googleProvider)
              .then((result) => {
                // Step 4
                // Link the SAML AuthCredential to the existing user.
                result.user.linkWithCredential(pendingCred)
                  .then((linkResult) => {
                    // SAML account successfully linked to the existing
                    // user.
                    goToApp();
                  });
              });
          }
        });
    }
  });
    multi-tenancy.js

  • Reindirizzamento

    Quando utilizzi signInWithRedirect, gli errori auth/account-exists-with-different-credential verranno generati in getRedirectResult al termine del flusso di reindirizzamento.

    L'oggetto errore contiene la proprietà error.tenantId. Poiché l'ID tenant nell'istanza auth non viene mantenuto dopo il reindirizzamento, dovrai impostare l'ID tenant dall'oggetto errore all'istanza auth.

    L'esempio seguente mostra come gestire l'errore:

    Versione web 9

    import { signInWithRedirect, getRedirectResult, fetchSignInMethodsForEmail, linkWithCredential } from "firebase/auth";
// Step 1.
// User tries to sign in to SAML provider.
auth.tenantId = 'TENANT_ID';
signInWithRedirect(auth, samlProvider);
var pendingCred;
// Redirect back from SAML IDP. auth.tenantId is null after redirecting.
getRedirectResult(auth).catch((error) => {
  if (error.code === 'auth/account-exists-with-different-credential') {
    // Step 2.
    // User's email already exists.
    const tenantId = error.tenantId;
    // The pending SAML credential.
    pendingCred = error.credential;
    // The provider account's email address.
    const email = error.customData.email;
    // Need to set the tenant ID again as the page was reloaded and the
    // previous setting was reset.
    auth.tenantId = tenantId;
    // Get sign-in methods for this email.
    fetchSignInMethodsForEmail(auth, email)
      .then((methods) => {
        // Step 3.
        // Ask the user to sign in with existing Google account.
        if (methods[0] == 'google.com') {
          signInWithRedirect(auth, googleProvider);
        }
      });
  }
});

// Redirect back from Google. auth.tenantId is null after redirecting.
getRedirectResult(auth).then((result) => {
  // Step 4
  // Link the SAML AuthCredential to the existing user.
  // result.user.tenantId is 'TENANT_ID'.
  linkWithCredential(result.user, pendingCred)
    .then((linkResult) => {
      // SAML account successfully linked to the existing
      // user.
      goToApp();
    });
});
    multitenant_account_exists_redirect.js

    Versione web 8

    // Step 1.
// User tries to sign in to SAML provider.
firebase.auth().tenantId = 'TENANT_ID';
firebase.auth().signInWithRedirect(samlProvider);
var pendingCred;
// Redirect back from SAML IDP. auth.tenantId is null after redirecting.
firebase.auth().getRedirectResult().catch((error) => {
  if (error.code === 'auth/account-exists-with-different-credential') {
    // Step 2.
    // User's email already exists.
    const tenantId = error.tenantId;
    // The pending SAML credential.
    pendingCred = error.credential;
    // The provider account's email address.
    const email = error.email;
    // Need to set the tenant ID again as the page was reloaded and the
    // previous setting was reset.
    firebase.auth().tenantId = tenantId;
    // Get sign-in methods for this email.
    firebase.auth().fetchSignInMethodsForEmail(email)
      .then((methods) => {
        // Step 3.
        // Ask the user to sign in with existing Google account.
        if (methods[0] == 'google.com') {
          firebase.auth().signInWithRedirect(googleProvider);
        }
      });
  }
});

// Redirect back from Google. auth.tenantId is null after redirecting.
firebase.auth().getRedirectResult().then((result) => {
  // Step 4
  // Link the SAML AuthCredential to the existing user.
  // result.user.tenantId is 'TENANT_ID'.
  result.user.linkWithCredential(pendingCred)
    .then((linkResult) => {
      // SAML account successfully linked to the existing
      // user.
      goToApp();
    });
});
    multi-tenancy.js

Disattivazione della creazione ed eliminazione degli account utente finali

In alcune situazioni, è preferibile che gli account utente vengano creati dagli amministratori anziché tramite le azioni degli utenti. In questi casi, puoi disattivare le azioni utente tramite la nostra API REST:

curl --location --request PATCH 'https://identitytoolkit.googleapis.com/v2/projects/PROJECT_ID/tenants/TENANT_ID?updateMask=client' \
  --header 'Authorization: Bearer AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "client": {
        "permissions": {
            "disabled_user_signup": true,
            "disabled_user_deletion": true
        }
    }
}'

Sostituisci quanto segue:

  • AUTH_TOKEN: il token di autenticazione.
  • PROJECT_ID: l'ID progetto.
  • TENANT_ID: l'ID tenant.

Passaggi successivi