Nutzer anmelden

Meggin Kearney
Meggin Kearney

Wenn du Nutzer anmelden möchtest, rufe die Anmeldedaten aus dem Passwortmanager des Browsers ab und verwende sie, um Nutzer automatisch anzumelden. Nutzer mit mehreren Konten können das gewünschte Konto mit nur einem Tippen über die Kontoauswahl auswählen.

Automatische Anmeldung

Die automatische Anmeldung kann überall auf Ihrer Website erfolgen, nicht nur auf der Startseite, sondern auch auf anderen Seiten. Das ist nützlich, wenn Nutzer über eine Suchmaschine auf verschiedene Seiten Ihrer Website gelangen.

So aktivieren Sie die automatische Anmeldung:

  1. Anmeldedaten abrufen
  2. Authentifizieren Sie den Nutzer.
  3. Aktualisieren Sie die Benutzeroberfläche oder rufen Sie die personalisierte Seite auf.

Anmeldedaten abrufen

Browser Support

  • Chrome: 51.
  • Edge: 18.
  • Firefox: 60.
  • Safari: 13.

Source

Rufen Sie navigator.credentials.get() auf, um Informationen zu den Anmeldedaten zu erhalten. Geben Sie den Typ der anzufordernden Anmeldedaten an, indem Sie password oder federated angeben.

Verwende für die automatische Anmeldung immer mediation: 'silent', damit du den Vorgang einfach verwerfen kannst, wenn der Nutzer:

  • Es sind keine Anmeldedaten gespeichert.
  • Mehrere Anmeldedaten gespeichert.
  • Sie sind abgemeldet.

Bevor Sie einen Berechtigungsnachweis abrufen, sollten Sie prüfen, ob der Nutzer bereits angemeldet ist:

if (window.PasswordCredential || window.FederatedCredential) {
  if (!user.isSignedIn()) {
    navigator.credentials.get({
      password: true,
      federated: {
        providers: ['https://accounts.google.com'],
      },
      mediation: 'silent',
    });
    // ...
  }
}

Das von navigator.credentials.get() zurückgegebene Promise wird entweder mit einem Anmeldedatenobjekt oder mit null aufgelöst. Um festzustellen, ob es sich um ein PasswordCredential oder ein FederatedCredential handelt, sehen Sie sich einfach das Attribut .type des Objekts an, das entweder password oder federated ist.

Wenn der .type federated ist, ist das Attribut .provider ein String, der den Identitätsanbieter darstellt.

Nutzer authentifizieren

Führen Sie nach Erhalt der Anmeldedaten einen Authentifizierungsablauf aus, je nach Art der Anmeldedaten, password oder federated:

    }).then(c => {
     if (c) {
       switch (c.type) {
         case 'password':
           return sendRequest(c);
           break;
         case 'federated':
           return gSignIn(c);
           break;
       }
     } else {
       return Promise.resolve();
     }

Wenn das Promise aufgelöst wird, prüfen Sie, ob Sie ein Anmeldedatenobjekt erhalten haben. Wenn nicht, konnte die automatische Anmeldung nicht durchgeführt werden. Schließen Sie den automatischen Anmeldevorgang im Hintergrund.

Benutzeroberfläche aktualisieren

Wenn die Authentifizierung erfolgreich ist, aktualisieren Sie die Benutzeroberfläche oder leiten Sie den Nutzer zur personalisierten Seite weiter:

    }).then(profile => {
     if (profile) {
       updateUI(profile);
     }

Don’t forget to show authentication error message

Damit Nutzer nicht verwirrt sind, sollte ihnen beim Abrufen des Anmeldedatenobjekts eine blaue Toast-Benachrichtigung mit dem Text „Anmeldung“ angezeigt werden:

Blauer Toast, der anzeigt, dass sich der Nutzer anmeldet.

Ein wichtiger Tipp: Wenn Sie ein Anmeldedatenobjekt erhalten, aber den Nutzer nicht authentifizieren können, sollten Sie eine Fehlermeldung anzeigen:

        }).catch(error => {
          showError('Sign-in Failed');
        });
      }
    }

Vollständiges Codebeispiel

if (window.PasswordCredential || window.FederatedCredential) {
  if (!user.isSignedIn()) {
    navigator.credentials
      .get({
        password: true,
        federated: {
          providers: ['https://accounts.google.com'],
        },
        mediation: 'silent',
      })
      .then((c) => {
        if (c) {
          switch (c.type) {
            case 'password':
              return sendRequest(c);
              break;
            case 'federated':
              return gSignIn(c);
              break;
          }
        } else {
          return Promise.resolve();
        }
      })
      .then((profile) => {
        if (profile) {
          updateUI(profile);
        }
      })
      .catch((error) => {
        showError('Sign-in Failed');
      });
  }
}

Anmeldung über die Kontoauswahl

Wenn ein Nutzer eine Vermittlung benötigt oder mehrere Konten hat, verwenden Sie die Kontoauswahl, damit sich der Nutzer anmelden kann. Das normale Anmeldeformular wird dabei übersprungen. Beispiel:

Google-Kontoauswahl mit mehreren Konten

Die Schritte für die Anmeldung über die Kontoauswahl sind dieselben wie bei der automatischen Anmeldung. Es gibt jedoch einen zusätzlichen Aufruf, um die Kontoauswahl im Rahmen des Abrufs von Anmeldedaten anzuzeigen:

  1. Anmeldedaten abrufen und Kontoauswahl anzeigen.
  2. Nutzer authentifizieren
  3. Aktualisieren Sie die Benutzeroberfläche oder rufen Sie eine personalisierte Seite auf.

Anmeldedaten abrufen und Kontoauswahl anzeigen

Eine Kontoauswahl als Reaktion auf eine definierte Nutzeraktion anzeigen, z. B. wenn der Nutzer auf die Schaltfläche „Anmelden“ tippt. Rufen Sie navigator.credentials.get() auf und fügen Sie mediation: 'optional' oder mediation: 'required' hinzu, um die Kontoauswahl anzuzeigen.

Wenn mediation den Wert required hat, wird dem Nutzer immer eine Kontoauswahl für die Anmeldung angezeigt. So können Nutzer mit mehreren Konten ganz einfach zwischen diesen wechseln. Wenn mediation den Wert optional hat, wird dem Nutzer nach einem navigator.credentials.preventSilentAccess()-Aufruf explizit eine Kontoauswahl zum Anmelden angezeigt. Normalerweise soll so verhindert werden, dass die automatische Anmeldung erfolgt, nachdem sich der Nutzer abgemeldet oder die Registrierung aufgehoben hat.

Beispiel für mediation: 'optional':

    var signin = document.querySelector('#signin');
    signin.addEventListener('click', e => {
     if (window.PasswordCredential || window.FederatedCredential) {
       navigator.credentials.get({
         password: true,
         federated: {
           providers: [
             'https://accounts.google.com'
           ]
         },
         mediation: 'optional'
       }).then(c => {

Sobald der Nutzer ein Konto ausgewählt hat, wird das Promise mit den Anmeldedaten aufgelöst. Wenn der Nutzer die Kontoauswahl abbricht oder keine Anmeldedaten gespeichert sind, wird das Promise mit null aufgelöst. In diesem Fall sollten Sie auf das Anmeldeformular zurückgreifen.

Vergessen Sie nicht, das Anmeldeformular als Fallback zu verwenden.

In den folgenden Fällen sollten Sie auf ein Anmeldeformular zurückgreifen:

  • Es werden keine Anmeldedaten gespeichert.
  • Der Nutzer hat die Kontoauswahl geschlossen, ohne ein Konto auszuwählen.
  • Die API ist nicht verfügbar.
    }).then(profile => {
        if (profile) {
          updateUI(profile);
        } else {
          location.href = '/signin';
        }
    }).catch(error => {
        location.href = '/signin';
    });

Vollständiges Codebeispiel

var signin = document.querySelector('#signin');
signin.addEventListener('click', (e) => {
  if (window.PasswordCredential || window.FederatedCredential) {
    navigator.credentials
      .get({
        password: true,
        federated: {
          providers: ['https://accounts.google.com'],
        },
        mediation: 'optional',
      })
      .then((c) => {
        if (c) {
          switch (c.type) {
            case 'password':
              return sendRequest(c);
              break;
            case 'federated':
              return gSignIn(c);
              break;
          }
        } else {
          return Promise.resolve();
        }
      })
      .then((profile) => {
        if (profile) {
          updateUI(profile);
        } else {
          location.href = '/signin';
        }
      })
      .catch((error) => {
        location.href = '/signin';
      });
  }
});

Föderierte Anmeldung

Mit der föderierten Anmeldung können sich Nutzer mit nur einem Tippen anmelden, ohne sich zusätzliche Anmeldedaten für deine Website merken zu müssen.

So implementieren Sie die föderierte Anmeldung:

  1. Nutzer mit einer Drittanbieteridentität authentifizieren.
  2. Speichern Sie die Identitätsinformationen.
  3. Aktualisieren Sie die Benutzeroberfläche oder rufen Sie eine personalisierte Seite auf (wie bei der automatischen Anmeldung).

Nutzer mit Drittanbieter-Identität authentifizieren

Wenn ein Nutzer auf eine Schaltfläche für die föderierte Anmeldung tippt, führen Sie den Authentifizierungsablauf des jeweiligen Identitätsanbieters mit dem FederatedCredential aus.

Browser Support

  • Chrome: 51.
  • Edge: 79.
  • Firefox: not supported.
  • Safari: not supported.

Source

Wenn der Anbieter beispielsweise Google ist, verwenden Sie die JavaScript-Bibliothek für Google Log-in:

navigator.credentials
  .get({
    password: true,
    mediation: 'optional',
    federated: {
      providers: ['https://account.google.com'],
    },
  })
  .then(function (cred) {
    if (cred) {
      // Instantiate an auth object
      var auth2 = gapi.auth2.getAuthInstance();

      // Is this user already signed in?
      if (auth2.isSignedIn.get()) {
        var googleUser = auth2.currentUser.get();

        // Same user as in the credential object?
        if (googleUser.getBasicProfile().getEmail() === cred.id) {
          // Continue with the signed-in user.
          return Promise.resolve(googleUser);
        }
      }

      // Otherwise, run a new authentication flow.
      return auth2.signIn({
        login_hint: id || '',
      });
    }
  });

Google Log-in liefert ein ID-Token als Authentifizierungsnachweis.

Im Allgemeinen basieren föderierte Log-ins auf Standardprotokollen wie OpenID Connect oder OAuth. Informationen zur Authentifizierung mit föderierten Konten finden Sie in der Dokumentation der jeweiligen föderierten Identitätsanbieter. Beliebte Beispiele:

Informationen zur Identität des Geschäfts

Nach der Authentifizierung können Sie die Identitätsinformationen speichern. Die Informationen, die Sie hier speichern, sind die id des Identitätsanbieters und ein Anbieterstring, der den Identitätsanbieter darstellt (name und iconURL sind optional). Weitere Informationen zu diesen Daten finden Sie in der Spezifikation zur Verwaltung von Anmeldedaten.

Wenn Sie Details zu einem föderierten Konto speichern möchten, instanziieren Sie ein neues FederatedCredential-Objekt mit der ID des Nutzers und der ID des Anbieters. Rufen Sie dann navigator.credentials.store() auf, um die Identitätsinformationen zu speichern.

Nach erfolgreicher Föderation instanziieren Sie einen FederatedCredential synchron oder asynchron:

Beispiel für einen synchronen Ansatz:

// Create credential object synchronously.
var cred = new FederatedCredential({
  id: id, // id in IdP
  provider: 'https://account.google.com', // A string representing IdP
  name: name, // name in IdP
  iconURL: iconUrl, // Profile image url
});

Beispiel für einen asynchronen Ansatz:

// Create credential object asynchronously.
var cred = await navigator.credentials.create({
  federated: {
    id: id,
    provider: 'https://accounts.google.com',
    name: name,
    iconURL: iconUrl,
  },
});

Speichern Sie dann das Anmeldedatenobjekt:

// Store it
navigator.credentials.store(cred).then(function () {
  // continuation
});

Abmelden

Melden Sie Nutzer ab, wenn sie auf die Schaltfläche zum Abmelden tippen. Beende zuerst die Sitzung und deaktiviere dann die automatische Anmeldung für zukünftige Besuche. (Wie Sie Ihre Sitzungen beenden, bleibt Ihnen überlassen.)

Automatische Anmeldung für zukünftige Besuche deaktivieren

navigator.credentials.preventSilentAccess() anrufen:

signoutUser();
if (navigator.credentials && navigator.credentials.preventSilentAccess) {
  navigator.credentials.preventSilentAccess();
}

So wird die automatische Anmeldung erst dann wieder ausgeführt, wenn der Nutzer sie das nächste Mal aktiviert. Wenn Nutzer die automatische Anmeldung wieder aktivieren möchten, können sie sich bewusst anmelden, indem sie in der Kontoauswahl das Konto auswählen, mit dem sie sich anmelden möchten. Der Nutzer wird dann immer wieder angemeldet, bis er sich explizit abmeldet.

Feedback