Mit JavaScript über Facebook Login authentifizieren

Sie können Ihren Nutzern erlauben, sich mit ihren Facebook-Konten bei Firebase zu authentifizieren indem Sie die Facebook-Anmeldung in Ihre App integrieren. Sie können Facebook-Log-in indem Sie entweder das Firebase SDK für die Anmeldung verwenden oder den Facebook-Anmeldevorgang manuell ausführen und das resultierende Zugriffstoken an Firebase

Hinweis

1. Fügen Sie Ihrem JavaScript-Projekt Firebase hinzu.
2. Auf Facebook for Developers erhalten Sie die App-ID und das App-Secret für Ihre App.
3. Facebook-Anmeldung aktivieren:
   1. Öffnen Sie in der Firebase-Konsole den Abschnitt Auth.
   2. Aktivieren Sie auf dem Tab Anmeldemethode die Anmeldemethode Facebook und geben Sie die App-ID und das App-Secret an, die Sie von Facebook erhalten haben.
   3. Prüfen Sie dann, ob Ihr OAuth-Weiterleitungs-URI (z. B. my-app-12345.firebaseapp.com/__/auth/handler) in der Konfiguration Produkteinstellungen > Facebook-Anmeldung auf der Seite „Einstellungen“ Ihrer Facebook-App auf der Website Facebook für Entwickler als einer Ihrer OAuth-Weiterleitungs-URIs aufgeführt ist.

Anmeldevorgang mit dem Firebase SDK durchführen

Wenn Sie eine Webanwendung erstellen, ist es am einfachsten, Ihre Nutzer zu authentifizieren. mit Firebase über die Facebook-Konten 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 Facebook-Anbieter-Objekts:
   WebWeb
   Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

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

   var provider = new firebase.auth.FacebookAuthProvider();
   facebook.js

2. Optional: Geben Sie zusätzliche OAuth 2.0-Bereiche an, die Sie Authentifizierungsanbieter beantragen möchten. Um einen Bereich hinzuzufügen, rufen Sie addScope Beispiel:
   WebWeb
   Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

   provider.addScope('user_birthday');
   auth_facebook_provider_scopes.js

   provider.addScope('user_birthday');
   facebook.js

   Siehe Authentifizierungsanbieter Dokumentation.
3. 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
   Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

   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

4. 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
   Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

   provider.setCustomParameters({
     'display': 'popup'
   });
   auth_facebook_provider_params.js

   provider.setCustomParameters({
     'display': 'popup'
   });
   facebook.js

   Reservierte erforderliche OAuth-Parameter sind nicht zulässig und werden ignoriert. Siehe Authentifizierungsanbieter-Referenz für weitere Informationen.
5. Authentifizieren Sie sich mit Firebase über das Facebook-Anbieterobjekt. Sie können fordern Sie Ihre Nutzer auf, sich mit ihrem Facebook-Konto anzumelden, indem sie 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
     Weitere Informationen zur modularen Web API, die durch Tree Shaking optimiert werden kann, und zum Upgrade von der API mit Namensraum.

     import { getAuth, signInWithPopup, FacebookAuthProvider } from "firebase/auth";
     
     const auth = getAuth();
     signInWithPopup(auth, provider)
       .then((result) => {
         // The signed-in user info.
         const user = result.user;
     
         // This gives you a Facebook Access Token. You can use it to access the Facebook API.
         const credential = FacebookAuthProvider.credentialFromResult(result);
         const accessToken = credential.accessToken;
     
         // 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 = FacebookAuthProvider.credentialFromError(error);
     
         // ...
       });
     auth_facebook_signin_popup.js

     firebase
       .auth()
       .signInWithPopup(provider)
       .then((result) => {
         /** @type {firebase.auth.OAuthCredential} */
         var credential = result.credential;
     
         // The signed-in user info.
         var user = result.user;
         // IdP data available in result.additionalUserInfo.profile.
           // ...
     
         // This gives you a Facebook Access Token. You can use it to access the Facebook API.
         var accessToken = credential.accessToken;
     
         // ...
       })
       .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

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

     Hier können Sie auch Fehler abfangen und behandeln. 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
     Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-API.

     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 Facebook-Anbieters abrufen, indem Sie 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, FacebookAuthProvider } from "firebase/auth";
     
     const auth = getAuth();
     getRedirectResult(auth)
       .then((result) => {
         // This gives you a Facebook Access Token. You can use it to access the Facebook API.
         const credential = FacebookAuthProvider.credentialFromResult(result);
         const token = credential.accessToken;
     
         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;
         // AuthCredential type that was used.
         const credential = FacebookAuthProvider.credentialFromError(error);
         // ...
       });
     auth_facebook_signin_redirect_result.js

     firebase.auth()
       .getRedirectResult()
       .then((result) => {
         if (result.credential) {
           /** @type {firebase.auth.OAuthCredential} */
           var credential = result.credential;
     
           // This gives you a Facebook Access Token. You can use it to access the Facebook API.
           var token = credential.accessToken;
           // ...
         }
         // 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;
         // ...
       });
     facebook.js

     Hier können Sie auch Fehler erkennen und beheben. Eine Liste der Fehlercodes finden Sie in der Referenzdokumentation zur Authentifizierung.

Hinweis: Facebook erzwingt HTTPS und erlaubt keine Anmeldung über unsichere Hosts. Nutzung von Facebook in der Entwicklungsphase mit einem http://localhost-Ursprung haben, müssen Sie darauf achten, ist für diese Facebook-App aktiviert. Außerdem ist die Anmeldung nur für mit Facebook-Testkonten.

Umgang mit Fehlern vom Typ „account-exists-with-different-credential“

Wenn Sie in der Firebase-Konsole die Einstellung Ein Konto pro E-Mail-Adresse aktiviert haben, Ein Nutzer versucht, sich mit einer E-Mail-Adresse bei einem Anbieter wie Facebook anzumelden, für den Anbieter eines anderen Firebase-Nutzers (z. B. Google) existiert, wird der Fehler auth/account-exists-with-different-credential wird zusammen mit einem AuthCredential-Objekt (Facebook-Zugriffstoken). 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 (Facebook-Zugriffstoken) 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,
  FacebookAuthProvider,
} from "firebase/auth";

try {
  // Step 1: User tries to sign in using Facebook.
  let result = await signInWithPopup(getAuth(), new FacebookAuthProvider());
} catch (error) {
  // Step 2: User's email already exists.
  if (error.code === "auth/account-exists-with-different-credential") {
    // The pending Facebook 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 Facebook 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 müssen zwischen Seitenweiterleitungen im Cache gespeichert werden (z. B. über Sitzungsspeicher).

Fortgeschrittene Nutzer: Anmeldevorgang manuell verarbeiten

Sie können sich auch mit einem Facebook-Konto bei Firebase authentifizieren, indem Sie den Anmeldevorgang mit dem Facebook Login JavaScript SDK verarbeiten:

1. Binden Sie Facebook Login in Ihre Anwendung ein. Folgen Sie dazu der Entwicklerdokumentation. Achten Sie darauf, die Facebook-Anmeldung mit Ihrer Facebook-App-ID zu konfigurieren:

   <script src="//connect.facebook.net/en_US/sdk.js"></script>
   <script>
     FB.init({
       /**********************************************************************
        * TODO(Developer): Change the value below with your Facebook app ID. *
        **********************************************************************/
       appId: '<YOUR_FACEBOOK_APP_ID>',
       status: true,
       xfbml: true,
       version: 'v2.6',
     });
   </script>

2. Außerdem richten wir einen Listener für den Facebook-Authentifizierungsstatus ein:

   FB.Event.subscribe('auth.authResponseChange', checkLoginState);

3. Nachdem Sie die Facebook-Anmeldung eingebunden haben, fügen Sie Ihren Webseiten eine Schaltfläche für die Facebook-Anmeldung hinzu:

   <fb:login-button
     data-auto-logout-link="true"
     scope="public_profile,email"
     size="large"
   ></fb:login-button>

4. Tausche im Facebook-Authentifizierungsstatus-Callback das Authentifizierungstoken aus der Authentifizierungsantwort von Facebook gegen ein Firebase-Anmeldedaten ein und melde dich bei Firebase an:
   WebWeb
   Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-API.

   import { getAuth, onAuthStateChanged, signInWithCredential, signOut, FacebookAuthProvider } from "firebase/auth";
   const auth = getAuth();
   
   function checkLoginState(response) {
     if (response.authResponse) {
       // User is signed-in Facebook.
       const unsubscribe = onAuthStateChanged(auth, (firebaseUser) => {
         unsubscribe();
         // Check if we are already signed-in Firebase with the correct user.
         if (!isUserEqual(response.authResponse, firebaseUser)) {
           // Build Firebase credential with the Facebook auth token.
           const credential = FacebookAuthProvider.credential(
               response.authResponse.accessToken);
   
           // Sign in with the credential from the Facebook user.
           signInWithCredential(auth, credential)
             .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);
               // ...
             });
         } else {
           // User is already signed-in Firebase with the correct user.
         }
       });
     } else {
       // User is signed-out of Facebook.
       signOut(auth);
     }
   }
   auth_facebook_callback.js

   function checkLoginState(response) {
     if (response.authResponse) {
       // User is signed-in Facebook.
       var unsubscribe = firebase.auth().onAuthStateChanged((firebaseUser) => {
         unsubscribe();
         // Check if we are already signed-in Firebase with the correct user.
         if (!isUserEqual(response.authResponse, firebaseUser)) {
           // Build Firebase credential with the Facebook auth token.
           var credential = firebase.auth.FacebookAuthProvider.credential(
               response.authResponse.accessToken);
   
           // Sign in with the credential from the Facebook user.
           firebase.auth().signInWithCredential(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;
               // ...
             });
         } else {
           // User is already signed-in Firebase with the correct user.
         }
       });
     } else {
       // User is signed-out of Facebook.
       firebase.auth().signOut();
     }
   }
   facebook.js

   Hier können Sie auch Fehler erkennen und beheben. Eine Liste der Fehlercodes findest du in den Auth-Referenzdokumenten.
5. Außerdem solltest du prüfen, ob der Facebook-Nutzer bereits in Firebase angemeldet ist, um unnötige erneute Authentifizierungen zu vermeiden:
   WebWeb
   Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-API.

   import { FacebookAuthProvider } from "firebase/auth";
   
   function isUserEqual(facebookAuthResponse, firebaseUser) {
     if (firebaseUser) {
       const providerData = firebaseUser.providerData;
       for (let i = 0; i < providerData.length; i++) {
         if (providerData[i].providerId === FacebookAuthProvider.PROVIDER_ID &&
             providerData[i].uid === facebookAuthResponse.userID) {
           // We don't need to re-auth the Firebase connection.
           return true;
         }
       }
     }
     return false;
   }
   auth_facebook_checksameuser.js

   function isUserEqual(facebookAuthResponse, firebaseUser) {
     if (firebaseUser) {
       var providerData = firebaseUser.providerData;
       for (var i = 0; i < providerData.length; i++) {
         if (providerData[i].providerId === firebase.auth.FacebookAuthProvider.PROVIDER_ID &&
             providerData[i].uid === facebookAuthResponse.userID) {
           // We don't need to re-auth the Firebase connection.
           return true;
         }
       }
     }
     return false;
   }
   facebook.js

Erweitert: Mit Firebase in Node.js authentifizieren

So authentifizieren Sie sich in einer Node.js-Anwendung mit Firebase:

1. Nutzer mit seinem Facebook-Konto anmelden und sein Facebook-Konto abrufen ein Zugriffstoken hinzufügen. Melden Sie den Nutzer beispielsweise in einem Browser an, wie im Abschnitt Anmeldevorgang manuell verarbeiten beschrieben, senden Sie das Zugriffstoken aber an Ihre Node.js-Anwendung, anstatt es in der Clientanwendung zu verwenden.
2. Nachdem Sie das Facebook-Zugriffstoken des Nutzers abgerufen haben, erstellen Sie damit ein Anmeldedatenobjekt und melden den Nutzer dann mit den Anmeldedaten an:
   WebWeb
   Informationen zur baumrüttbaren modularen Web API und Upgrade ausführen aus der Namespace-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

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

Mit Firebase in einer Chrome-Erweiterung authentifizieren

Wenn Sie eine App für eine Chrome-Erweiterung erstellen, lesen Sie die Leitfaden zu nicht sichtbaren Dokumenten.

Weiterleitungsdomain für die Facebook-Anmeldung 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 sehen können, während sie sich bei Facebook anmelden, bevor sie zur Anwendung weitergeleitet werden: Weiter zu: https://my-app-12345.firebaseapp.com.

Wenn Sie verhindern möchten, dass Ihre Subdomain angezeigt wird, können Sie eine benutzerdefinierte Domain mit Firebase Hosting einrichten:

1. Führen Sie die Schritte 1 bis 3 unter Domain für Hosting einrichten aus. 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 der Liste der autorisierten Domains in der Firebase-Konsole: auth.custom.domain.com.
3. Fügen Sie in der Facebook-Entwicklerkonsole oder auf der OAuth-Einrichtungsseite die URL der Weiterleitungsseite auf die Zulassungsliste, auf die über Ihre benutzerdefinierte Domain zugegriffen werden kann:https://auth.custom.domain.com/__/auth/handler.
4. Geben Sie beim Initialisieren der JavaScript-Bibliothek Ihre benutzerdefinierte Domain im Feld authDomain an:

   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 Firebase Realtime Database und Cloud Storage Sicherheitsregeln können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der Variablen auth abrufen, und steuern, auf welche Daten ein Nutzer zugreifen kann.

Sie können Nutzern erlauben, sich über mehrere Authentifizierungsanbieter in Ihrer App anzumelden, indem Sie Anmeldedaten des Authentifizierungsanbieters mit einem vorhandenen Nutzerkonto verknüpfen.

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