Diese Seite wurde von der Cloud Translation API übersetzt.

Authentifizieren Sie sich mit Twitter in JavaScript

Sie können Ihren Benutzern die Authentifizierung bei Firebase über ihre Twitter-Konten ermöglichen, indem Sie die Twitter-Authentifizierung in Ihre App integrieren. Sie können die Twitter-Authentifizierung integrieren, indem Sie entweder das Firebase SDK verwenden, um den Anmeldevorgang auszuführen, oder indem Sie den Twitter-OAuth-Ablauf manuell ausführen und das resultierende Zugriffstoken und Geheimnis an Firebase übergeben.

Bevor Sie beginnen

Fügen Sie Firebase zu Ihrem JavaScript-Projekt hinzu .
Öffnen Sie in der Firebase-Konsole den Abschnitt „Auth“ .
Aktivieren Sie auf der Registerkarte Anmeldemethode den Twitter- Anbieter.
Fügen Sie den API-Schlüssel und das API-Geheimnis von der Entwicklerkonsole dieses Anbieters zur Anbieterkonfiguration hinzu:
1. Registrieren Sie Ihre App als Entwickleranwendung auf Twitter und erhalten Sie den OAuth- API-Schlüssel und das API-Geheimnis Ihrer App.
2. Stellen Sie sicher, dass Ihr Firebase OAuth-Umleitungs-URI (z. B. my-app-12345.firebaseapp.com/__/auth/handler ) auf der Einstellungsseite Ihrer App in der Konfiguration Ihrer Twitter-App als Autorisierungs-Callback-URL festgelegt ist.
Klicken Sie auf Speichern .

Behandeln Sie den Anmeldevorgang mit dem Firebase SDK

Wenn Sie eine Web-App erstellen, besteht die einfachste Möglichkeit zur Authentifizierung Ihrer Benutzer bei Firebase mithilfe ihrer Twitter-Konten darin, den Anmeldevorgang mit dem Firebase JavaScript SDK abzuwickeln. (Wenn Sie einen Benutzer in Node.js oder einer anderen Nicht-Browser-Umgebung authentifizieren möchten, müssen Sie den Anmeldevorgang manuell durchführen.)

Führen Sie die folgenden Schritte aus, um den Anmeldevorgang mit dem Firebase JavaScript SDK abzuwickeln:

Erstellen Sie eine Instanz des Twitter-Anbieterobjekts:

Web modular API

import { TwitterAuthProvider } from "firebase/auth";

const provider = new TwitterAuthProvider();auth_twitter_provider_create.js

Web namespaced API

var provider = new firebase.auth.TwitterAuthProvider();twitter.js

Optional : Um den OAuth-Ablauf des Anbieters auf die bevorzugte Sprache des Benutzers zu lokalisieren, ohne die relevanten benutzerdefinierten OAuth-Parameter explizit zu übergeben, aktualisieren Sie den Sprachcode auf der Auth-Instanz, bevor Sie den OAuth-Ablauf starten. Zum Beispiel:
Web modular API
Erfahren Sie mehr über die strukturveränderbare modulare Web-API und das Upgrade von der Namespace-API.
```
import { getAuth } from "firebase/auth";

const auth = getAuth();
auth.languageCode = 'it';
// To apply the default browser preference instead of explicitly setting it.
// firebase.auth().useDeviceLanguage();auth_set_language_code.js
```
Web namespaced API
```
firebase.auth().languageCode = 'it';
// To apply the default browser preference instead of explicitly setting it.
// firebase.auth().useDeviceLanguage();index.js
```
Optional : Geben Sie zusätzliche benutzerdefinierte OAuth-Anbieterparameter an, die Sie mit der OAuth-Anfrage senden möchten. Um einen benutzerdefinierten Parameter hinzuzufügen, rufen Sie setCustomParameters für den initialisierten Anbieter mit einem Objekt auf, das den in der Dokumentation des OAuth-Anbieters angegebenen Schlüssel und den entsprechenden Wert enthält. Zum Beispiel:
Web modular API
Erfahren Sie mehr über die strukturveränderbare modulare Web-API und das Upgrade von der Namespace-API.
```
provider.setCustomParameters({
  'lang': 'es'
});auth_twitter_provider_params.js
```
Web namespaced API
```
provider.setCustomParameters({
  'lang': 'es'
});twitter.js
```
Reservierte erforderliche OAuth-Parameter sind nicht zulässig und werden ignoriert. Weitere Einzelheiten finden Sie in der Referenz zum Authentifizierungsanbieter .

Authentifizieren Sie sich bei Firebase mithilfe des Twitter-Anbieterobjekts. Sie können Ihre Benutzer auffordern, sich mit ihren Twitter-Konten anzumelden, indem Sie entweder ein Popup-Fenster öffnen oder zur Anmeldeseite weiterleiten. Auf Mobilgeräten wird die Weiterleitungsmethode bevorzugt.

Um sich mit einem Popup-Fenster anzumelden, rufen Sie signInWithPopup auf:

Web modular API

import { getAuth, signInWithPopup, TwitterAuthProvider } from "firebase/auth";

const auth = getAuth();
signInWithPopup(auth, provider)
  .then((result) => {
    // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
    // You can use these server side with your app's credentials to access the Twitter API.
    const credential = TwitterAuthProvider.credentialFromResult(result);
    const token = credential.accessToken;
    const secret = credential.secret;

    // The signed-in user info.
    const user = result.user;
    // IdP data available using getAdditionalUserInfo(result)
    // ...
  }).catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The AuthCredential type that was used.
    const credential = TwitterAuthProvider.credentialFromError(error);
    // ...
  });auth_twitter_signin_popup.js

Web namespaced API

firebase
  .auth()
  .signInWithPopup(provider)
  .then((result) => {
    /** @type {firebase.auth.OAuthCredential} */
    var credential = result.credential;

    // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
    // You can use these server side with your app's credentials to access the Twitter API.
    var token = credential.accessToken;
    var secret = credential.secret;

    // The signed-in user info.
    var user = result.user;
    // IdP data available in result.additionalUserInfo.profile.
      // ...
  }).catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;
    // ...
  });twitter.js

Beachten Sie außerdem, dass Sie das OAuth-Token des Twitter-Anbieters abrufen können, mit dem Sie mithilfe der Twitter-APIs zusätzliche Daten abrufen können.

Hier können Sie auch Fehler erkennen und beheben. Eine Liste der Fehlercodes finden Sie in den Auth-Referenzdokumenten .

Um sich durch Weiterleitung zur Anmeldeseite anzumelden, rufen Sie signInWithRedirect auf: Befolgen Sie die Best Practices bei der Verwendung von „signInWithRedirect“.

Web modular API

import { getAuth, signInWithRedirect } from "firebase/auth";

const auth = getAuth();
signInWithRedirect(auth, provider);auth_signin_redirect.js

Web namespaced API

firebase.auth().signInWithRedirect(provider);index.js

Anschließend können Sie das OAuth-Token des Twitter-Anbieters auch abrufen, indem Sie beim Laden Ihrer Seite getRedirectResult aufrufen:

Web modular API

import { getAuth, getRedirectResult, TwitterAuthProvider } from "firebase/auth";

const auth = getAuth();
getRedirectResult(auth)
  .then((result) => {
    // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
    // You can use these server side with your app's credentials to access the Twitter API.
    const credential = TwitterAuthProvider.credentialFromResult(result);
    const token = credential.accessToken;
    const secret = credential.secret;
    // ...

    // The signed-in user info.
    const user = result.user;
    // IdP data available using getAdditionalUserInfo(result)
    // ...
  }).catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The AuthCredential type that was used.
    const credential = TwitterAuthProvider.credentialFromError(error);
    // ...
  });auth_twitter_signin_redirect_result.js

Web namespaced API

firebase.auth()
  .getRedirectResult()
  .then((result) => {
    if (result.credential) {
      /** @type {firebase.auth.OAuthCredential} */
      var credential = result.credential;

      // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
      // You can use these server side with your app's credentials to access the Twitter API.
      var token = credential.accessToken;
      var secret = credential.secret;
      // ...
    }

    // The signed-in user info.
    var user = result.user;
    // IdP data available in result.additionalUserInfo.profile.
      // ...
  }).catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;
    // ...
  });twitter.js

Hier können Sie auch Fehler erkennen und beheben. Eine Liste der Fehlercodes finden Sie in den Auth-Referenzdokumenten .

Behandeln von Konto-existiert-mit-anderen-Anmeldeinformationen-Fehlern

Wenn Sie die Einstellung „Ein Konto pro E-Mail-Adresse“ in der Firebase-Konsole aktiviert haben und ein Benutzer versucht, sich bei einem Anbieter (z. B. Twitter) mit einer E-Mail-Adresse anzumelden, die bereits für den Anbieter eines anderen Firebase-Benutzers (z. B. Google) vorhanden ist, wird der Fehler angezeigt auth/account-exists-with-different-credential wird zusammen mit einem AuthCredential Objekt (Twitter-OAuth-Token und -Geheimnis) ausgelöst. Um die Anmeldung beim vorgesehenen Anbieter abzuschließen, muss sich der Benutzer zunächst beim vorhandenen Anbieter (Google) anmelden und dann eine Verknüpfung mit dem früheren AuthCredential (Twitter-OAuth-Token und -Geheimnis) herstellen.

Wenn Sie signInWithPopup verwenden, können Sie auth/account-exists-with-different-credential Fehler mit Code wie dem folgenden Beispiel behandeln:


// Step 1.
// User tries to sign in to Twitter.
auth.signInWithPopup(new firebase.auth.TwitterAuthProvider()).catch(function(error) {
  // An error happened.
  if (error.code === 'auth/account-exists-with-different-credential') {
    // Step 2.
    // User's email already exists.
    // The pending Twitter credential.
    var pendingCred = error.credential;
    // The provider account's email address.
    var email = error.email;
    // Get sign-in methods for this email.
    auth.fetchSignInMethodsForEmail(email).then(function(methods) {
      // Step 3.
      // If the user has several sign-in methods,
      // the first method in the list will be the "recommended" method to use.
      if (methods[0] === 'password') {
        // Asks the user their password.
        // In real scenario, you should handle this asynchronously.
        var password = promptUserForPassword(); // TODO: implement promptUserForPassword.
        auth.signInWithEmailAndPassword(email, password).then(function(result) {
          // Step 4a.
          return result.user.linkWithCredential(pendingCred);
        }).then(function() {
          // Twitter account successfully linked to the existing Firebase user.
          goToApp();
        });
        return;
      }
      // All the other cases are external providers.
      // Construct provider object for that provider.
      // TODO: implement getProviderForProviderId.
      var provider = getProviderForProviderId(methods[0]);
      // At this point, you should let the user know that they already have an account
      // but with a different provider, and let them validate the fact they want to
      // sign in with this provider.
      // Sign in to provider. Note: browsers usually block popup triggered asynchronously,
      // so in real scenario you should ask the user to click on a "continue" button
      // that will trigger the signInWithPopup.
      auth.signInWithPopup(provider).then(function(result) {
        // Remember that the user may have signed in with an account that has a different email
        // address than the first one. This can happen as Firebase doesn't control the provider's
        // sign in flow and the user is free to login using whichever account they own.
        // Step 4b.
        // Link to Twitter credential.
        // As we have access to the pending credential, we can directly call the link method.
        result.user.linkAndRetrieveDataWithCredential(pendingCred).then(function(usercred) {
          // Twitter account successfully linked to the existing Firebase user.
          goToApp();
        });
      });
    });
  }
});

Umleitungsmodus

Dieser Fehler wird im Umleitungsmodus auf ähnliche Weise behandelt, mit dem Unterschied, dass die ausstehenden Anmeldeinformationen zwischen Seitenumleitungen zwischengespeichert werden müssen (z. B. mithilfe des Sitzungsspeichers).

Behandeln Sie den Anmeldevorgang manuell

Sie können sich auch über ein Twitter-Konto bei Firebase authentifizieren, indem Sie den Anmeldevorgang durch Aufrufen der Twitter-OAuth-Endpunkte verwalten:

Integrieren Sie die Twitter-Authentifizierung in Ihre App, indem Sie der Dokumentation des Entwicklers folgen. Am Ende des Twitter-Anmeldevorgangs erhalten Sie ein OAuth-Zugriffstoken und ein OAuth-Geheimnis.
Wenn Sie sich bei einer Node.js-Anwendung anmelden müssen, senden Sie das OAuth-Zugriffstoken und das OAuth-Geheimnis an die Node.js-Anwendung.
Nachdem sich ein Benutzer erfolgreich bei Twitter angemeldet hat, tauschen Sie das OAuth-Zugriffstoken und das OAuth-Geheimnis gegen eine Firebase-Anmeldeinformation aus:
```
var credential = firebase.auth.TwitterAuthProvider.credential(token, secret);
```

Authentifizieren Sie sich bei Firebase mit den Firebase-Anmeldeinformationen:

Web modular API

import { getAuth, signInWithCredential, FacebookAuthProvider } from "firebase/auth";

// Sign in with the credential from the Facebook user.
const auth = getAuth();
signInWithCredential(auth, credential)
  .then((result) => {
    // Signed in 
    const credential = FacebookAuthProvider.credentialFromResult(result);
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The AuthCredential type that was used.
    const credential = FacebookAuthProvider.credentialFromError(error);
    // ...
  });auth_facebook_signin_credential.js

Web namespaced API

// Sign in with the credential from the Facebook user.
firebase.auth().signInWithCredential(credential)
  .then((result) => {
    // Signed in       
    var credential = result.credential;
    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;
    // ...
  });facebook.js

Authentifizieren Sie sich mit Firebase in einer Chrome-Erweiterung

Wenn Sie eine Chrome-Erweiterungs-App erstellen, müssen Sie Ihre Chrome-Erweiterungs-ID hinzufügen:

Öffnen Sie Ihr Projekt in der Firebase-Konsole .
Öffnen Sie im Abschnitt Authentifizierung die Seite Anmeldemethode .
Fügen Sie der Liste der autorisierten Domänen einen URI wie den folgenden hinzu:
```
chrome-extension://CHROME_EXTENSION_ID
```

Für Chrome-Erweiterungen stehen nur Popup-Vorgänge ( signInWithPopup , linkWithPopup und reauthenticateWithPopup ) zur Verfügung, da Chrome-Erweiterungen keine HTTP-Weiterleitungen verwenden können. Sie sollten diese Methoden über ein Hintergrundseitenskript und nicht über ein Browser-Aktions-Popup aufrufen, da das Authentifizierungs-Popup das Browser-Aktions-Popup abbricht. Die Popup-Methoden dürfen nur in Erweiterungen verwendet werden, die Manifest V2 verwenden. Das neuere Manifest V3 erlaubt nur Hintergrundskripte in Form von Service-Workern, die die Popup-Vorgänge überhaupt nicht ausführen können.

Stellen Sie in der Manifestdatei Ihrer Chrome-Erweiterung sicher, dass Sie die URL https://apis.google.com zur Zulassungsliste content_security_policy hinzufügen.

Bei der Projekterstellung stellt Firebase eine eindeutige Subdomain für Ihr Projekt bereit: https://my-app-12345.firebaseapp.com .

Dies wird auch als Umleitungsmechanismus für die OAuth-Anmeldung verwendet. Diese Domäne müsste für alle unterstützten OAuth-Anbieter zugelassen sein. Dies bedeutet jedoch, dass Benutzer möglicherweise diese Domäne sehen, während sie sich bei Twitter anmelden, bevor sie zur Anwendung zurückkehren: Weiter zu: https://my-app-12345.firebaseapp.com .

Um die Anzeige Ihrer Subdomain zu vermeiden, können Sie mit Firebase Hosting eine benutzerdefinierte Domain einrichten:

Befolgen Sie die Schritte 1 bis 3 unter Einrichten Ihrer Domain für das Hosting . Wenn Sie den Besitz Ihrer Domain verifizieren, stellt Hosting ein SSL-Zertifikat für Ihre benutzerdefinierte Domain bereit.
Fügen Sie Ihre benutzerdefinierte Domäne zur Liste der autorisierten Domänen in der Firebase-Konsole hinzu: auth.custom.domain.com .
Setzen Sie in der Twitter-Entwicklerkonsole oder auf der OAuth-Setup-Seite die URL der Umleitungsseite auf die Whitelist, auf die über Ihre benutzerdefinierte Domain zugegriffen werden kann: https://auth.custom.domain.com/__/auth/handler .

Wenn Sie die JavaScript-Bibliothek initialisieren, geben Sie Ihre benutzerdefinierte Domäne mit dem Feld authDomain an:

var config = {
  apiKey: '...',
  // Changed from 'my-app-12345.firebaseapp.com'.
  authDomain: 'auth.custom.domain.com',
  databaseURL: 'https://my-app-12345.firebaseio.com',
  projectId: 'my-app-12345',
  storageBucket: 'my-app-12345.appspot.com',
  messagingSenderId: '1234567890'
};
firebase.initializeApp(config);

Nächste Schritte

Nachdem sich ein Benutzer zum ersten Mal angemeldet hat, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen – also dem Benutzernamen und dem Kennwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter – verknüpft, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann zur Identifizierung eines Benutzers in jeder App in Ihrem Projekt verwendet werden, unabhängig davon, wie sich der Benutzer anmeldet.

In Ihren Apps können Sie den Authentifizierungsstatus Ihres Benutzers am besten ermitteln, indem Sie einen Beobachter für das Auth Objekt festlegen. Anschließend können Sie die grundlegenden Profilinformationen des Benutzers aus dem User abrufen. Siehe Benutzer verwalten .
In Ihren Firebase-Echtzeitdatenbank- und Cloud-Speicher- Sicherheitsregeln können Sie die eindeutige Benutzer-ID des angemeldeten Benutzers aus der auth abrufen und damit steuern, auf welche Daten ein Benutzer zugreifen kann.

Sie können Benutzern die Anmeldung bei Ihrer App mit mehreren Authentifizierungsanbietern ermöglichen, indem Sie die Anmeldeinformationen des Authentifizierungsanbieters mit einem vorhandenen Benutzerkonto verknüpfen.

Um einen Benutzer abzumelden, rufen Sie signOut auf:

Web modular API

import { getAuth, signOut } from "firebase/auth";

const auth = getAuth();
signOut(auth).then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});auth_sign_out.js

Web namespaced API

firebase.auth().signOut().then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});index.js

Authentifizieren Sie sich mit Twitter in JavaScript

Bevor Sie beginnen

Behandeln Sie den Anmeldevorgang mit dem Firebase SDK

Web modular API

Web namespaced API

Web modular API

Web namespaced API

Web modular API

Web namespaced API

Web modular API

Web namespaced API

Web modular API

Web namespaced API

Web modular API

Web namespaced API

Behandeln von Konto-existiert-mit-anderen-Anmeldeinformationen-Fehlern

Popup-Modus

Umleitungsmodus

Behandeln Sie den Anmeldevorgang manuell

Web modular API

Web namespaced API

Authentifizieren Sie sich mit Firebase in einer Chrome-Erweiterung

Anpassen der Weiterleitungsdomäne für die Twitter-Anmeldung

Nächste Schritte

Web modular API

Web namespaced API