Benutzerdefinierte Anmeldeseite erstellen

In diesem Artikel erfahren Sie, wie Sie mit externen Identitäten und IAP eine eigene Authentifizierungsseite erstellen. Wenn Sie diese Seite selbst erstellen, haben Sie die vollständige Kontrolle über den Authentifizierungsablauf und die Nutzererfahrung.

Wenn Sie Ihre Benutzeroberfläche nicht vollständig anpassen müssen, können Sie IAP eine Anmeldeseite für Sie hosten lassen oder FirebaseUI verwenden, um die Nutzung zu optimieren.

Überblick

So erstellen Sie eine eigene Authentifizierungsseite:

  1. Externe Identitäten aktivieren Wählen Sie bei der Einrichtung die Option Ich gebe meine eigene UI-Option aus.
  2. Installieren Sie die gcip-iap-Bibliothek.
  3. Konfigurieren Sie die Benutzeroberfläche, indem Sie die AuthenticationHandler-Schnittstelle implementieren. Ihre Authentifizierungsseite muss die folgenden Szenarien unterstützen:
    • Mandantenauswahl
    • Nutzerautorisierung
    • Nutzeranmeldung
    • Fehlerbehandlung
  4. Optional: Passen Sie Ihre Authentifizierungsseite mit zusätzlichen Funktionen an, z. B. Fortschrittsbalken, Abmeldeseiten und Nutzerverarbeitung.
  5. Teste deine UI.

gcip-iap-Bibliothek installieren

Führen Sie den folgenden Befehl aus, um die gcip-iap-Bibliothek zu installieren:

npm install gcip-iap --save

Das NPM-Modul gcip-iap abstrahiert die Kommunikation zwischen Ihrer Anwendung, IAP und Identity Platform. So können Sie den gesamten Authentifizierungsablauf anpassen, ohne die zugrunde liegenden Austausche zwischen der UI und IAP verwalten zu müssen.

Verwenden Sie die korrekten Importe für Ihre SDK-Version:

gcip-iap v0.1.4 oder niedriger 

// Import Firebase/GCIP dependencies. These are installed on npm install.
import * as firebase from 'firebase/app';
import 'firebase/auth';
// Import GCIP/IAP module.
import * as ciap from 'gcip-iap';

gcip-iap Version 1.0.0 bis 1.1.0

Ab Version 1.0.0 ist für gcip-iap mindestens eine Peer-Abhängigkeit von firebase Version 9 erforderlich. Wenn Sie zu gcip-iap v1.0.0 oder höher migrieren, führen Sie die folgenden Schritte aus:

  • Aktualisieren Sie die firebase-Version in Ihrer package.json-Datei auf Version 9.6.0 oder höher.
  • Aktualisieren Sie die Importanweisungen für firebase so:
// Import Firebase modules.
import firebase from 'firebase/compat/app';
import 'firebase/compat/auth';
// Import the gcip-iap module.
import * as ciap from 'gcip-iap';

Es sind keine zusätzlichen Codeänderungen erforderlich.

gcip-iap Version 2.0.0

Ab Version 2.0.0 muss Ihre benutzerdefinierte UI-Anwendung für gcip-iap im modularen SDK-Format umgeschrieben werden. Wenn Sie zu gcip-iap v2.0.0 oder höher migrieren, führen Sie die folgenden Schritte aus:

  • Aktualisieren Sie die firebase-Version in Ihrer package.json-Datei auf Version 9.8.3 oder höher.
  • Aktualisieren Sie die Importanweisungen für firebase so:
  // Import Firebase modules.
  import { initializeApp } from 'firebase/app';
  import { getAuth, GoogleAuthProvider } 'firebase/auth';
  // Import the gcip-iap module.
  import * as ciap from 'gcip-iap';

Benutzeroberfläche konfigurieren

Erstellen Sie zum Konfigurieren der UI eine benutzerdefinierte Klasse, die die Schnittstelle AuthenticationHandler implementiert:

interface AuthenticationHandler {
  languageCode?: string | null;
  getAuth(apiKey: string, tenantId: string | null): FirebaseAuth;
  startSignIn(auth: FirebaseAuth, match?: SelectedTenantInfo): Promise<UserCredential>;
  selectTenant?(projectConfig: ProjectConfig, tenantIds: string[]): Promise<SelectedTenantInfo>;
  completeSignOut(): Promise<void>;
  processUser?(user: User): Promise<User>;
  showProgressBar?(): void;
  hideProgressBar?(): void;
  handleError?(error: Error | CIAPError): void;
}

Während der Authentifizierung ruft die Bibliothek automatisch die Methoden von AuthenticationHandler auf.

Mandanten auswählen

Implementieren Sie selectTenant(), um einen Mandanten auszuwählen. Sie können diese Methode implementieren, um einen Mandanten programmatisch auszuwählen oder eine UI anzeigen zu lassen, damit der Nutzer selbst einen Mandanten auswählen kann.

In beiden Fällen verwendet die Bibliothek das zurückgegebene SelectedTenantInfo-Objekt, um den Authentifizierungsvorgang abzuschließen. Es enthält die ID des ausgewählten Mandanten, alle Anbieter-IDs und die E-Mail-Adresse, die der Nutzer eingegeben hat.

Wenn Ihr Projekt mehrere Mandanten enthält, müssen Sie einen Mandanten auswählen, bevor Sie einen Nutzer authentifizieren können. Wenn Sie nur einen einzelnen Mandanten haben oder die Authentifizierung auf Projektebene verwenden, müssen Sie selectTenant() nicht implementieren.

IAP unterstützt die gleichen Anbieter wie Identity Platform:

  • E-Mail-Adresse und Passwort
  • OAuth (Google, Facebook, Twitter, GitHub, Microsoft usw.)
  • SAML
  • OIDC
  • Telefonnummer
  • Benutzerdefiniert
  • Anonym

Die Authentifizierungstypen "Telefonnummer", "Benutzerdefinierte" und "Anonym" werden für Mehrmandantenfähigkeit nicht unterstützt.

Mandanten programmatisch auswählen

Wenn Sie einen Mandanten programmatisch auswählen möchten, nutzen Sie den aktuellen Kontext. Die Klasse Authentication enthält getOriginalURL(), die die URL zurückgibt, auf die der Nutzer vor der Authentifizierung zugegriffen hat.

Damit können Sie eine Übereinstimmung in einer Liste der zugehörigen Mandanten finden:

// Select provider programmatically.
selectTenant(projectConfig, tenantIds) {
  return new Promise((resolve, reject) => {
    // Show UI to select the tenant.
    auth.getOriginalURL()
      .then((originalUrl) => {
        resolve({
          tenantId: getMatchingTenantBasedOnVisitedUrl(originalUrl),
          // If associated provider IDs can also be determined,
          // populate this list.
          providerIds: [],
        });
      })
      .catch(reject);
  });
}

Nutzer dürfen Mandanten auswählen

Damit der Nutzer einen Mandanten auswählen kann, rufen Sie eine Liste mit Mandanten auf und lassen Sie den Nutzer einen auswählen. Alternativ können Sie ihn auch bitten, seine E-Mail-Adresse einzugeben und dann eine Übereinstimmung anhand der Domain zu suchen:

// Select provider by showing UI.
selectTenant(projectConfig, tenantIds) {
  return new Promise((resolve, reject) => {
    // Show UI to select the tenant.
    renderSelectTenant(
        tenantIds,
        // On tenant selection.
        (selectedTenantId) => {
          resolve({
            tenantId: selectedTenantId,
            // If associated provider IDs can also be determined,
            // populate this list.
            providerIds: [],
            // If email is available, populate this field too.
            email: undefined,
          });
        });
  });
}

Nutzer authentifizieren

Nachdem Sie einen Anbieter gefunden haben, implementieren Sie getAuth(), um eine Auth-Instanz zurückzugeben, die dem bereitgestellten API-Schlüssel und der Mandanten-ID entspricht. Wenn keine Mandanten-ID angegeben ist, verwenden Sie Identitätsanbieter auf Projektebene.

getAuth() verfolgt, wo der Nutzer, der der angegebenen Konfiguration entspricht, gespeichert wird. Außerdem ist es damit möglich, das Identity Platform-ID-Token eines zuvor authentifizierten Nutzers im Hintergrund zu aktualisieren, ohne dass der Nutzer seine Anmeldedaten noch einmal eingeben muss.

Wenn Sie mehrere IAP-Ressourcen mit verschiedenen Mandanten verwenden, wird empfohlen, für jede Ressource eine eindeutige Authentifizierungsinstanz zu verwenden. Dadurch können Sie mehrere Ressourcen mit unterschiedlichen Konfigurationen die gleiche Authentifizierungsseite nutzen. Außerdem bietet es mehreren Nutzern die Möglichkeit, sich gleichzeitig anzumelden, ohne dass der vorherige Nutzer abgemeldet werden muss.

Im Folgenden finden Sie ein Beispiel für die Implementierung von getAuth():

gcip-iap v1.0.0 

getAuth(apiKey, tenantId) {
  let auth = null;
  // Make sure the expected API key is being used.
  if (apiKey !== expectedApiKey) {
    throw new Error('Invalid project!');
  }
  try {
    auth = firebase.app(tenantId || undefined).auth();
    // Tenant ID should be already set on initialization below.
  } catch (e) {
    // Use different App names for every tenant so that
    // multiple users can be signed in at the same time (one per tenant).
    const app = firebase.initializeApp(this.config, tenantId || '[DEFAULT]');
    auth = app.auth();
    // Set the tenant ID on the Auth instance.
    auth.tenantId = tenantId || null;
  }
  return auth;
}

gcip-iap v2.0.0 

import {initializeApp, getApp} from 'firebase/app';
import {getAuth} from 'firebase/auth';

getAuth(apiKey, tenantId) {
  let auth = null;
  // Make sure the expected API key is being used.
  if (apiKey !== expectedApiKey) {
    throw new Error('Invalid project!');
  }
  try {
    auth = getAuth(getApp(tenantId || undefined));
    // Tenant ID should be already set on initialization below.
  } catch (e) {
    // Use different App names for every tenant so that
    // multiple users can be signed in at the same time (one per tenant).
    const app = initializeApp(this.config, tenantId || '[DEFAULT]');
    auth = getAuth(app);
    // Set the tenant ID on the Auth instance.
    auth.tenantId = tenantId || null;
  }
  return auth;
}

Nutzer anmelden

Implementieren Sie zur Verarbeitung der Anmeldung startSignIn(), rufen Sie eine UI für die Authentifizierung des Nutzers auf und geben Sie nach Abschluss des Vorgangs ein UserCredential für den angemeldeten Nutzer zurück.

In einer mehrmandantenfähigen Umgebung können Sie die verfügbaren Authentifizierungsmethoden über SelectedTenantInfo ermitteln, sofern diese Methode angegeben wurde. Diese Variable enthält die Informationen, die von selectTenant() zurückgegeben werden.

Das folgende Beispiel zeigt eine startSignIn()-Implementierung für einen vorhandenen Nutzer mit einer E-Mail-Adresse und einem Passwort:

gcip-iap v1.0.0 

startSignIn(auth, selectedTenantInfo) {
  return new Promise((resolve, reject) => {
    // Show the UI to sign-in or sign-up a user.
    $('#sign-in-form').on('submit', (e) => {
      const email = $('#email').val();
      const password = $('#password').val();
      // Example: Ask the user for an email and password.
      // Note: The method of sign in may have already been determined from the
      // selectedTenantInfo object.
      auth.signInWithEmailAndPassword(email, password)
        .then((userCredential) => {
          resolve(userCredential);
        })
        .catch((error) => {
          // Show the error message.
        });
    });
  });
}

gcip-iap v2.0.0 

import {signInWithEmailAndPassword} from 'firebase/auth';

startSignIn(auth, selectedTenantInfo) {
  return new Promise((resolve, reject) => {
    // Show the UI to sign-in or sign-up a user.
    $('#sign-in-form').on('submit', (e) => {
      const email = $('#email').val();
      const password = $('#password').val();
      // Example: Ask the user for an email and password.
      // Note: The method of sign in may have already been determined from the
      // selectedTenantInfo object.
        signInWithEmailAndPassword(auth, email, password)
        .then((userCredential) => {
          resolve(userCredential);
        })
        .catch((error) => {
          // Show the error message.
        });
    });
  });
}

Sie haben auch die Möglichkeit, Nutzer mit einem Föderationsanbieter wie SAML oder OIDC über ein Pop-up-Fenster oder eine Weiterleitung anzumelden:

gcip-iap v1.0.0 

startSignIn(auth, selectedTenantInfo) {
  // Show the UI to sign-in or sign-up a user.
  return new Promise((resolve, reject) => {
    // Provide the user multiple buttons to sign-in.
    // For example sign-in with popup using a SAML provider.
    // Note: The method of sign in may have already been determined from the
    // selectedTenantInfo object.
    const provider = new firebase.auth.SAMLAuthProvider('saml.myProvider');
    auth.signInWithPopup(provider)
      .then((userCredential) => {
        resolve(userCredential);
      })
      .catch((error) => {
        // Show the error message.
      });
    // Using redirect flow. When the page redirects back and sign-in completes,
    // ciap will detect the result and complete sign-in without any additional
    // action.
    auth.signInWithRedirect(provider);
  });
}

gcip-iap v2.0.0 

import {signInWithPopup, SAMLAuthProvider} from 'firebase/auth';

startSignIn(auth, selectedTenantInfo) {
  // Show the UI to sign-in or sign-up a user.
  return new Promise((resolve, reject) => {
    // Provide the user multiple buttons to sign-in.
    // For example sign-in with popup using a SAML provider.
    // Note: The method of sign in might have already been determined from the
    // selectedTenantInfo object.
    const provider = new SAMLAuthProvider('saml.myProvider');
    signInWithPopup(auth, provider)
      .then((userCredential) => {
        resolve(userCredential);
      })
      .catch((error) => {
        // Show the error message.
      });
    // Using redirect flow. When the page redirects back and sign-in completes,
    // ciap will detect the result and complete sign-in without any additional
    // action.
    signInWithRedirect(auth, provider);
  });
}

Einige OAuth-Anbieter unterstützen die Übergabe eines Hinweises für die Anmeldung:

gcip-iap v1.0.0 

startSignIn(auth, selectedTenantInfo) {
  // Show the UI to sign-in or sign-up a user.
  return new Promise((resolve, reject) => {
    // Use selectedTenantInfo to determine the provider and pass the login hint
    // if that provider supports it and the user specified an email address.
    if (selectedTenantInfo &&
        selectedTenantInfo.providerIds &&
        selectedTenantInfo.providerIds.indexOf('microsoft.com') !== -1) {
      const provider = new firebase.auth.OAuthProvider('microsoft.com');
      provider.setCustomParameters({
        login_hint: selectedTenantInfo.email || undefined,
      });
    } else {
      // Figure out the provider used...
    }
    auth.signInWithPopup(provider)
      .then((userCredential) => {
        resolve(userCredential);
      })
      .catch((error) => {
        // Show the error message.
      });
    });
}

gcip-iap v2.0.0 

import {signInWithPopup, OAuthProvider} from 'firebase/auth';

startSignIn(auth, selectedTenantInfo) {
  // Show the UI to sign in or sign up a user.
  return new Promise((resolve, reject) => {
    // Use selectedTenantInfo to determine the provider and pass the login hint
    // if that provider supports it and the user specified an email address.
    if (selectedTenantInfo &&
        selectedTenantInfo.providerIds &&
        selectedTenantInfo.providerIds.indexOf('microsoft.com') !== -1) {
      const provider = new OAuthProvider('microsoft.com');
      provider.setCustomParameters({
        login_hint: selectedTenantInfo.email || undefined,
      });
    } else {
      // Figure out the provider used...
    }
    signInWithPopup(auth, provider)
      .then((userCredential) => {
        resolve(userCredential);
      })
      .catch((error) => {
        // Show the error message.
      });
    });
}

Weitere Informationen finden Sie unter Mit Mehrmandantenfähigkeit authentifizieren.

Fehlerbehebung

Wenn Sie Fehlermeldungen für Nutzer anzeigen oder eine Wiederherstellung nach Fehlern wie Netzwerkzeitüberschreitungen versuchen möchten, implementieren Sie handleError().

Im folgenden Beispiel wird handleError() implementiert:

handleError(error) {
  showAlert({
    code: error.code,
    message: error.message,
    // Whether to show the retry button. This is only available if the error is
    // recoverable via retrial.
    retry: !!error.retry,
  });
  // When user clicks retry, call error.retry();
  $('.alert-link').on('click', (e) => {
    error.retry();
    e.preventDefault();
    return false;
  });
}

In der folgenden Tabelle sind die IAP-spezifischen Fehlercodes aufgeführt, die zurückgegeben werden können. Identity Platform kann auch Fehler zurückgeben. Weitere Informationen finden Sie in der Dokumentation zu firebase.auth.Auth.

Fehlercode Beschreibung
invalid-argument Der Client hat ein ungültiges Argument angegeben.
failed-precondition Die Anfrage kann im aktuellen Systemzustand nicht ausgeführt werden.
out-of-range Der Client hat einen ungültigen Bereich angegeben.
unauthenticated Die Anfrage wurde aufgrund eines fehlenden, ungültigen oder abgelaufenen OAuth-Tokens nicht authentifiziert.
permission-denied Der Client hat keine ausreichende Berechtigungen oder die UI wird in einer nicht autorisierten Domain gehostet.
not-found Die angegebene Ressource wurde nicht gefunden.
aborted Es ist ein Konflikt aufgrund von gleichzeitig ausgeführten Aktionen aufgetreten, beispielsweise ein Read-Modify-Write-Konflikt.
already-exists Die Ressource, die ein Client erstellen möchte, ist bereits vorhanden.
resource-exhausted Es wurde entweder das Ressourcenkontingent überschritten oder das Ratenlimit erreicht.
cancelled Die Anfrage wurde vom Client abgebrochen.
data-loss Es ist ein dauerhafter Datenverlust oder Datenkorruption aufgetreten.
unknown Unbekannter Serverfehler.
internal Interner Serverfehler.
not-implemented Die API-Methode wurde vom Server nicht implementiert.
unavailable Dienst ist nicht verfügbar.
restart-process Sie müssen die URL, über die Sie auf diese Seite weitergeleitet wurden, noch einmal aufrufen und den Authentifizierungsprozess neu starten.
deadline-exceeded Die Frist der Anfrage wurde überschritten.
authentication-uri-fail Authentifizierungs-URI konnte nicht generiert werden.
gcip-token-invalid Ein ungültiges GCIP-ID-Token wurde angegeben.
gcip-redirect-invalid Ungültige Weiterleitungs-URL.
get-project-mapping-fail Fehler beim Abrufen der Projekt-ID.
gcip-id-token-encryption-error Fehler bei der GCIP-ID-Token-Verschlüsselung.
gcip-id-token-decryption-error Fehler bei der Entschlüsselung des GCIP-ID-Tokens.
gcip-id-token-unescape-error Fehler beim Aufheben der Escapezeichen für die websichere Base64-Codierung.
resource-missing-gcip-sign-in-url GCIP-Authentifizierungs-URL für die angegebene IAP-Ressource ist nicht vorhanden.

Benutzeroberfläche anpassen

Sie können Ihre Authentifizierungsseite mit optionalen Funktionen wie Fortschrittsanzeigen und Abmeldeseiten anpassen.

Fortschrittsanzeige darstellen

Damit dem Nutzer immer dann eine benutzerdefinierte Fortschritts-UI angezeigt wird, wenn das gcip-iap-Modul lang andauernde Netzwerkaufgaben ausführt, implementieren Sie showProgressBar() und hideProgressBar().

Nutzer abmelden

In einigen Fällen kann es sinnvoll sein, Nutzern das Abmelden von allen aktuellen Sitzungen zu erlauben, die die gleiche Authentifizierungs-URL nutzen.

Nachdem sich ein Nutzer abgemeldet hat, gibt es möglicherweise keine URL, zu der er weitergeleitet werden kann. Dies tritt häufig auf, wenn sich ein Nutzer von allen Mandanten abmeldet, die mit einer Anmeldeseite verknüpft sind. Implementieren Sie in diesem Fall completeSignOut(), um eine Meldung anzuzeigen, die besagt, dass der Nutzer erfolgreich abgemeldet wurde. Wenn Sie diese Methode nicht implementieren, wird nach der Abmeldung eine leere Seite angezeigt.

Nutzer, die verarbeitet werden

Wenn Sie einen angemeldeten Nutzer ändern möchten, bevor Sie zur IAP-Ressource weitergeleitet werden, implementieren Sie processUser().

Sie können diese Methode für Folgendes verwenden:

  • Mit weiteren Anbietern verknüpfen
  • Nutzerprofil aktualisieren
  • Nutzer nach der Registrierung zur Eingabe zusätzlicher Daten auffordern
  • OAuth-Zugriffstoken verarbeiten, die von getRedirectResult() nach dem Aufruf von signInWithRedirect() zurückgegeben werden

Im Folgenden finden Sie ein Beispiel für die Implementierung von processUser():

gcip-iap v1.0.0 

processUser(user) {
  return lastAuthUsed.getRedirectResult().then(function(result) {
    // Save additional data, or ask the user for additional profile information
    // to store in database, etc.
    if (result) {
      // Save result.additionalUserInfo.
      // Save result.credential.accessToken for OAuth provider, etc.
    }
    // Return the user.
    return user;
  });
}

gcip-iap v2.0.0 

import {getRedirectResult} from 'firebase/auth';

processUser(user) {
  return getRedirectResult(lastAuthUsed).then(function(result) {
    // Save additional data, or ask the user for additional profile information
    // to store in database, etc.
    if (result) {
      // Save result.additionalUserInfo.
      // Save result.credential.accessToken for OAuth provider, etc.
    }
    // Return the user.
    return user;
  });
}

Wenn Änderungen an einem Nutzer in den ID-Token-Anforderungen, die von IAP an Ihre Anwendung weitergegeben werden, berücksichtigt werden sollen, müssen Sie die Aktualisierung des Tokens erzwingen:

gcip-iap v1.0.0 

processUser(user) {
  return user.updateProfile({
    photoURL: 'https://example.com/profile/1234/photo.png',
  }).then(function() {
    // To reflect updated photoURL in the ID token, force token
    // refresh.
    return user.getIdToken(true);
  }).then(function() {
    return user;
  });
}

gcip-iap v2.0.0 

import {updateProfile} from 'firebase/auth';

processUser(user) {
  return updateProfile(user, {
    photoURL: 'https://example.com/profile/1234/photo.png',
  }).then(function() {
    // To reflect updated photoURL in the ID token, force token
    // refresh.
    return user.getIdToken(true);
  }).then(function() {
    return user;
  });
}

UI testen

Nachdem Sie eine Klasse erstellt haben, die AuthenticationHandler implementiert, können Sie damit eine neue Authentication-Instanz erstellen und starten:

// Implement interface AuthenticationHandler.
// const authHandlerImplementation = ....
const ciapInstance = new ciap.Authentication(authHandlerImplementation);
ciapInstance.start();

Stellen Sie Ihre Anwendung bereit und rufen Sie die Authentifizierungsseite auf. Anschließend sollte Ihre benutzerdefinierte Anmeldungs-UI angezeigt werden.

Nächste Schritte