Mit Twitter in JavaScript authentifizieren

Sie können Ihren Nutzern erlauben, sich mit ihren Twitter-Konten bei Firebase zu authentifizieren indem Sie die Twitter-Authentifizierung in Ihre App integrieren. Sie können Twitter Authentifizierung entweder mithilfe des Firebase SDK für die Anmeldung, oder den Twitter-OAuth-Vorgang manuell ausführen und den resultierenden Zugriffs-Token und Secret an Firebase übergeben.

Hinweis

1. Fügen Sie Ihrem JavaScript-Projekt Firebase hinzu.
2. Öffnen Sie in der Firebase Console den Bereich Auth.
3. Aktivieren Sie auf dem Tab Anmeldemethode den Twitter-Anbieter.
4. Fügen Sie der Anbieterkonfiguration den API-Schlüssel und das API-Secret aus der Entwicklerkonsole des Anbieters hinzu:
   1. Registriere deine App als Entwickler-App bei Twitter und erhalte den OAuth-API-Schlüssel und das API-Secret deiner App.
   2. Prüfen Sie, ob der OAuth-Weiterleitungs-URI von Firebase (z.B. my-app-12345.firebaseapp.com/__/auth/handler) die als Callback-URL für die Autorisierung festgelegt ist. Wählen Sie dazu in den App-Einstellungen auf Ihrem Konfiguration der Twitter-App
5. Klicken Sie auf Speichern.

Anmeldevorgang mit dem Firebase SDK durchführen

Wenn Sie eine Webanwendung erstellen, ist es am einfachsten, Ihre Nutzer zu authentifizieren. mit Firebase und ihren Twitter-Konten ist die Anmeldung mit das Firebase JavaScript SDK. Wenn Sie einen Nutzer in Node.js oder einer anderen nicht browserbasierten Umgebung authentifizieren möchten, müssen Sie den Anmeldevorgang manuell abwickeln.

So verwalten Sie den Anmeldevorgang mit dem Firebase JavaScript SDK:

1. Erstellen Sie eine Instanz des Twitter-Anbieter-Objekts:
   WebWeb
   Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-API.

   import { TwitterAuthProvider } from "firebase/auth";
   
   const provider = new TwitterAuthProvider();
   auth_twitter_provider_create.js

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

2. Optional: Wenn du den OAuth-Ablauf des Anbieters in der bevorzugten Sprache des Nutzers lokalisieren möchtest, ohne die entsprechenden benutzerdefinierten OAuth-Parameter explizit zu übergeben, aktualisiere den Sprachcode in der Auth-Instanz, bevor du den OAuth-Ablauf startest. Beispiel:
   WebWeb
   Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus 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.
   // auth.useDeviceLanguage();
   auth_set_language_code.js

   firebase.auth().languageCode = 'it';
   // To apply the default browser preference instead of explicitly setting it.
   // firebase.auth().useDeviceLanguage();
   index.js

3. Optional: Geben Sie zusätzliche benutzerdefinierte OAuth-Anbieterparameter an, die mit der OAuth-Anfrage gesendet werden sollen. Um einen benutzerdefinierten Parameter hinzuzufügen, rufen Sie setCustomParameters beim initialisierten Anbieter mit einem Objekt, das den Schlüssel enthält OAuth-Anbieter und im entsprechenden Wert angegeben. Beispiel:
   WebWeb
   Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-API.

   provider.setCustomParameters({
     'lang': 'es'
   });
   auth_twitter_provider_params.js

   provider.setCustomParameters({
     'lang': 'es'
   });
   twitter.js

   Reservierte erforderliche OAuth-Parameter sind nicht zulässig und werden ignoriert. Siehe Authentifizierungsanbieter-Referenz für weitere Informationen.
4. Authentifizieren Sie sich bei Firebase mithilfe des Twitter-Anbieterobjekts. Sie können fordern Sie Ihre Nutzer auf, sich mit ihrem Twitter-Konto anzumelden, indem sie entweder ein Pop-up-Fenster öffnen oder zur Anmeldeseite weitergeleitet werden. Die Weiterleitungsmethode ist auf Mobilgeräten bevorzugt.
   • Wenn Sie sich über ein Pop-up-Fenster anmelden möchten, drücken Sie signInWithPopup:
     WebWeb
     Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-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

     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 zusätzliche Daten mithilfe der Twitter-APIs abgerufen werden können.

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

   • Wenn Sie sich durch Weiterleitung zur Anmeldeseite anmelden möchten, rufen Sie signInWithRedirect auf: Folgen Sie den Best Practices für die Verwendung von „signInWithWeiterleitung“.
     WebWeb
     Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

     import { getAuth, signInWithRedirect } from "firebase/auth";
     
     const auth = getAuth();
     signInWithRedirect(auth, provider);
     auth_signin_redirect.js

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

     Dann können Sie auch das OAuth-Token des Twitter-Anbieters abrufen, indem Sie folgenden Befehl aufrufen: getRedirectResult beim Laden der Seite:
     WebWeb
     Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

     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

     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 der Referenzdokumentation zur Authentifizierung.

Fehler beim Vorhandensein eines Kontos mit unterschiedlichen Anmeldedaten beheben

Wenn Sie in der Firebase Console die Einstellung Ein Konto pro E-Mail-Adresse aktiviert haben und ein Nutzer versucht, sich bei einem Anbieter (z. B. Twitter) mit einer E-Mail-Adresse anzumelden, die bereits für den Anbieter eines anderen Firebase-Nutzers (z. B. Google) vorhanden ist, wird der Fehler auth/account-exists-with-different-credential zusammen mit einem AuthCredential-Objekt (Twitter-OAuth-Token und -Secret) ausgelöst. Um die Anmeldung beim gewünschten Anbieter abzuschließen, muss sich der Nutzer zuerst beim bestehenden Anbieter (Google) anmelden und dann eine Verknüpfung zum ehemaligen AuthCredential (Twitter-OAuth-Token und -Secret) herstellen.

Pop-up-Modus

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

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

try {
  // Step 1: User tries to sign in using Twitter.
  let result = await signInWithPopup(getAuth(), new TwitterAuthProvider());
} catch (error) {
  // Step 2: User's email already exists.
  if (error.code === "auth/account-exists-with-different-credential") {
    // The pending Twitter credential.
    let pendingCred = error.credential;

    // Step 3: Save the pending credential in temporary storage,

    // Step 4: Let the user know that they already have an account
    // but with a different provider, and let them choose another
    // sign-in method.
  }
}

// ...

try {
  // Step 5: Sign the user in using their chosen method.
  let result = await signInWithPopup(getAuth(), userSelectedProvider);

  // Step 6: Link to the Twitter credential.
  // TODO: implement `retrievePendingCred` for your app.
  let pendingCred = retrievePendingCred();

  if (pendingCred !== null) {
    // As you have access to the pending credential, you can directly call the
    // link method.
    let user = await linkWithCredential(result.user, pendingCred);
  }

  // Step 7: Continue to app.
} catch (error) {
  // ...
}

Weiterleitungsmodus

Dieser Fehler wird im Weiterleitungsmodus ähnlich behandelt, mit dem Unterschied, dass die ausstehenden Anmeldedaten zwischen den Seitenweiterleitungen im Cache gespeichert werden müssen (z. B. mit Sitzungsspeicher).

Anmeldevorgang manuell verarbeiten

Sie können sich auch mit einem Twitter-Konto bei Firebase authentifizieren, indem Sie den Anmeldevorgang durch Aufrufen der Twitter-OAuth-Endpunkte:

1. Binden Sie die Twitter-Authentifizierung in Ihre Anwendung ein. Folgen Sie dazu der Entwicklerdokumentation. Am Ende des Twitter-Anmeldevorgangs erhältst du ein OAuth-Zugriffstoken und ein OAuth-Secret.
2. Wenn Sie sich in einer Node.js-Anwendung anmelden müssen, senden Sie den OAuth-Zugriff und das OAuth-Secret für die Node.js-Anwendung.
3. Nachdem sich ein Nutzer erfolgreich bei Twitter angemeldet hat, tauschen Sie den OAuth-Zugriff aus. Token und OAuth-Secret für Firebase-Anmeldedaten:

   var credential = firebase.auth.TwitterAuthProvider.credential(token, secret);

4. Authentifizieren Sie sich mit den Firebase-Anmeldedaten bei Firebase:
   WebWeb
   Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

   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

   // 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

In einer Chrome-Erweiterung mit Firebase authentifizieren

Wenn Sie eine Chrome-Erweiterung entwickeln, lesen Sie den Leitfaden zu Offscreen-Dokumenten.

Weiterleitungsdomain für die Anmeldung in Twitter anpassen

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

Diese wird auch als Weiterleitungsmechanismus für die OAuth-Anmeldung verwendet. Diese Domain muss für alle unterstützten OAuth-Anbieter zulässig sein. Das bedeutet jedoch, dass Nutzer diese Domain möglicherweise sehen, während sie sich bei Twitter anmelden, bevor sie zur Anwendung weitergeleitet werden: Weiter zu: https://my-app-12345.firebaseapp.com.

Wenn Sie Ihre Subdomain nicht anzeigen lassen möchten, können Sie eine benutzerdefinierte Domain mit Firebase Hosting einrichten:

1. Befolgen Sie die Schritte 1 bis 3 in Richten Sie Ihre Domain für Hosting ein. Nach der Bestätigung Ihrer Domaininhaberschaft erhalten, stellt Hosting ein SSL-Zertifikat für Ihre benutzerdefinierte Domain bereit.
2. Fügen Sie Ihre benutzerdefinierte Domain in der Firebase-Konsole der Liste der autorisierten Domains hinzu: auth.custom.domain.com.
3. Setzen Sie in der Twitter-Entwicklerkonsole oder auf der OAuth-Einrichtungsseite die URL der Weiterleitungsseite auf die weiße Liste. auf die Sie in Ihrer benutzerdefinierten Domain zugreifen können: https://auth.custom.domain.com/__/auth/handler
4. Beim Initialisieren der JavaScript-Bibliothek geben Sie Ihre benutzerdefinierte Domain mit dem Feld authDomain:

   var config = {
     apiKey: '...',
     // Changed from 'PROJECT_ID.firebaseapp.com'.
     authDomain: 'auth.custom.domain.com',
     databaseURL: 'https://PROJECT_ID.firebaseio.com',
     projectId: 'PROJECT_ID',
     storageBucket: 'PROJECT_ID.firebasestorage.app',
     messagingSenderId: 'SENDER_ID'
   };
   firebase.initializeApp(config);

Nächste Schritte

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, d. h. mit dem Nutzernamen und Passwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter, mit denen sich der Nutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in allen Apps in Ihrem Projekt zu identifizieren, unabhängig davon, wie er sich anmeldet.

• Um den Authentifizierungsstatus Ihrer Nutzer in Ihren Apps zu ermitteln, gehen Sie folgendermaßen vor: einen Beobachter für das Auth-Objekt festlegen. Sie können dann die E-Mail-Adresse grundlegende Profilinformationen aus dem User-Objekt. Weitere Informationen finden Sie unter Nutzer verwalten:

• In Ihren Firebase Realtime Database- und Cloud Storage-Sicherheitsregeln können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der Variablen auth abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

Sie können Nutzern erlauben, sich mit Mehrfachauthentifizierung in Ihrer App anzumelden indem Sie die Anmeldedaten des Authentifizierungsanbieters mit einem eines bestehenden Nutzerkontos.

Rufen Sie auf, um einen Nutzer abzumelden. signOut:

WebWeb

Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-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

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