Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Mit JavaScript über GitHub authentifizieren

Sie können Nutzern die Authentifizierung mit Firebase über ihre GitHub-Konten ermöglichen, indem Sie die GitHub-Authentifizierung in Ihre App einbinden. Sie können die GitHub-Authentifizierung entweder über das Firebase SDK oder manuell über den GitHub-OAuth 2.0-Vorgang einbinden und das resultierende Zugriffstoken an Firebase übergeben.

Hinweis

Firebase zu Ihrem JavaScript-Projekt hinzufügen
Wechseln Sie in der Firebase-Konsole zu Sicherheit > Authentifizierung.
Aktivieren Sie auf dem Tab Anmeldemethode den Anmeldeanbieter GitHub.
Fügen Sie der Anbieterkonfiguration die Client-ID und den Clientschlüssel aus der Entwicklerkonsole des Anbieters hinzu:
1. Registrieren Sie Ihre App als Entwickleranwendung auf GitHub und rufen Sie die OAuth 2.0-Client-ID und den Clientschlüssel Ihrer App ab.
2. Achten Sie darauf, dass der OAuth-Weiterleitungs-URI von Firebase (z. B. my-app-12345.firebaseapp.com/__/auth/handler) als Callback-URL für die Autorisierung auf der Einstellungsseite Ihrer App in der Konfiguration Ihrer GitHub-App festgelegt ist.
Klicken Sie auf Speichern.

Anmeldevorgang mit dem Firebase SDK verarbeiten

Wenn Sie eine Web-App entwickeln, ist die einfachste Möglichkeit, Ihre Nutzer mit Firebase über ihre GitHub-Konten zu authentifizieren, den Anmeldevorgang mit dem Firebase JavaScript SDK zu verarbeiten. Wenn Sie einen Nutzer in Node.js oder einer anderen Umgebung ohne Browser authentifizieren möchten, müssen Sie den Anmeldevorgang manuell durchführen.

So verarbeiten Sie den Anmeldevorgang mit dem Firebase JavaScript SDK:

Erstellen Sie eine Instanz des GitHub-Anbieter-Objekts:

Web

import { GithubAuthProvider } from "firebase/auth";

const provider = new GithubAuthProvider();auth_github_provider_create.js

Web

var provider = new firebase.auth.GithubAuthProvider();github.js

Optional: Geben Sie zusätzliche OAuth 2.0-Bereiche an, die Sie vom Authentifizierungsanbieter anfordern möchten. Rufen Sie addScope auf, um einen Bereich hinzuzufügen. Beispiel:
Web
```
provider.addScope('repo');auth_github_provider_scopes.js
```
Web
```
provider.addScope('repo');github.js
```
Weitere Informationen finden Sie in der Dokumentation zum Authentifizierungsanbieter.
Optional: Geben Sie zusätzliche benutzerdefinierte OAuth-Anbieterparameter an, die mit der OAuth-Anfrage gesendet werden sollen. Wenn Sie einen benutzerdefinierten Parameter hinzufügen möchten, rufen Sie setCustomParameters für den initialisierten Anbieter mit einem Objekt auf, das den Schlüssel (wie in der Dokumentation des OAuth-Anbieters angegeben) und den entsprechenden Wert enthält. Beispiel:
Web
```
provider.setCustomParameters({
  'allow_signup': 'false'
});auth_github_provider_params.js
```
Web
```
provider.setCustomParameters({
  'allow_signup': 'false'
});github.js
```
Reservierte erforderliche OAuth-Parameter sind nicht zulässig und werden ignoriert. Weitere Informationen finden Sie in der Referenz zum Authentifizierungsanbieter.

Authentifizieren Sie sich mit Firebase über das GitHub-Anbieterobjekt. Sie können Ihre Nutzer auffordern, sich mit ihren GitHub-Konten anzumelden, indem Sie entweder ein Pop-up-Fenster öffnen oder zur Anmeldeseite weiterleiten. Die Weiterleitungsmethode wird auf Mobilgeräten bevorzugt.

Wenn Sie sich mit einem Pop-up-Fenster anmelden möchten, rufen Sie signInWithPopup auf:

Web

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

const auth = getAuth();
signInWithPopup(auth, provider)
  .then((result) => {
    // This gives you a GitHub Access Token. You can use it to access the GitHub API.
    const credential = GithubAuthProvider.credentialFromResult(result);
    const token = credential.accessToken;

    // 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 = GithubAuthProvider.credentialFromError(error);
    // ...
  });auth_github_signin_popup.js

Web

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

    // This gives you a GitHub Access Token. You can use it to access the GitHub 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;
    // ...
  });github.js

Sie können auch das OAuth-Token des GitHub-Anbieters abrufen, mit dem zusätzliche Daten über die GitHub-APIs abgerufen werden können.

Hier können Sie auch Fehler abfangen und behandeln. Eine Liste der Fehlercodes finden Sie in der Auth-Referenzdokumentation.

Wenn Sie sich anmelden möchten, indem Sie zur Anmeldeseite weitergeleitet werden, rufen Sie signInWithRedirect auf: Halten Sie sich bei der Verwendung von `signInWithRedirect` an die Best Practices.

Web

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

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

Web

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

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

Web

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

const auth = getAuth();
getRedirectResult(auth)
  .then((result) => {
    const credential = GithubAuthProvider.credentialFromResult(result);
    if (credential) {
      // This gives you a GitHub Access Token. You can use it to access the GitHub API.
      const token = credential.accessToken;
      // ...
    }

    // 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 = GithubAuthProvider.credentialFromError(error);
    // ...
  });auth_github_signin_redirect_result.js

Web

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

      // This gives you a GitHub Access Token. You can use it to access the GitHub 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;
    // ...
  });github.js

Hier können Sie auch Fehler abfangen und behandeln. Eine Liste der Fehlercodes finden Sie in der Auth-Referenzdokumentation.

Fehler „account-exists-with-different-credential“ beheben

Wenn Sie in der Firebase-Konsole die Einstellung Ein Konto pro E-Mail-Adresse aktiviert haben und ein Nutzer versucht, sich mit einer E-Mail-Adresse bei einem Anbieter (z. B. GitHub) 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 (GitHub-Zugriffstoken) ausgegeben. Um die Anmeldung beim gewünschten Anbieter abzuschließen, muss sich der Nutzer zuerst beim vorhandenen Anbieter (Google) anmelden und dann eine Verknüpfung mit dem bisherigen AuthCredential (GitHub-Zugriffstoken) herstellen.

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,
  GitHubAuthProvider,
} from "firebase/auth";

try {
  // Step 1: User tries to sign in using GitHub.
  let result = await signInWithPopup(getAuth(), new GitHubAuthProvider());
} catch (error) {
  // Step 2: User's email already exists.
  if (error.code === "auth/account-exists-with-different-credential") {
    // The pending GitHub 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 GitHub 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. Der Unterschied besteht darin, dass das ausstehende Anmeldedatenobjekt zwischen Seitenweiterleitungen im Cache gespeichert werden muss (z. B. mit dem Sitzungsspeicher).

Anmeldevorgang manuell verarbeiten

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

Bauen Sie die GitHub-Authentifizierung in Ihre App ein. Folgen Sie dazu der Entwicklerdokumentation. Am Ende des GitHub-Anmeldevorgangs erhalten Sie ein OAuth 2.0-Zugriffstoken.
Wenn Sie sich in einer Node.js-Anwendung anmelden müssen, senden Sie das OAuth-Zugriffstoken an die Node.js-Anwendung.

Nachdem sich ein Nutzer erfolgreich mit GitHub angemeldet hat, tauschen Sie das OAuth 2.0-Zugriffstoken gegen Anmeldedaten für Firebase ein:

Web

import { GithubAuthProvider } from "firebase/auth";

const credential = GithubAuthProvider.credential(token);auth_github_provider_credential.js

Web

var credential = firebase.auth.GithubAuthProvider.credential(token);github.js

Authentifizieren Sie sich mit dem Firebase-Anmeldedaten bei Firebase:

Web

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

// Sign in with the credential from the user.
const auth = getAuth();
signInWithCredential(auth, credential)
  .then((result) => {
    // Signed in 
    // ...
  })
  .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;
    // ...
  });auth_signin_credential.js

Web

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

Authentifizierung mit Firebase in einer Chrome-Erweiterung

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

Beim Erstellen eines Projekts stellt Firebase eine eindeutige Subdomain für Ihr Projekt bereit: https://my-app-12345.firebaseapp.com.

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

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

Folgen Sie der Anleitung in den Schritten 1 bis 3 unter Domain für Hosting einrichten. Wenn Sie die Inhaberschaft Ihrer Domain bestätigen, stellt Hosting ein SSL-Zertifikat für Ihre benutzerdefinierte Domain bereit.
Fügen Sie Ihre benutzerdefinierte Domain der Liste der autorisierten Domains in der Firebase-Konsole hinzu: auth.custom.domain.com.
Fügen Sie in der GitHub-Entwicklerkonsole oder auf der OAuth-Einrichtungsseite die URL der Weiterleitungsseite auf die Whitelist, die über Ihre benutzerdefinierte Domain aufgerufen werden kann: https://auth.custom.domain.com/__/auth/handler.

Wenn Sie die JavaScript-Bibliothek initialisieren, geben Sie Ihre benutzerdefinierte Domain mit dem 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

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

In Ihren Apps ist es am besten, den Authentifizierungsstatus des Nutzers zu ermitteln, indem Sie einen Observer für das Auth-Objekt festlegen. Anschließend können Sie die grundlegenden Profilinformationen des Nutzers aus dem User-Objekt abrufen. 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 auth-Variablen abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

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

Rufen Sie signOut auf, um einen Nutzer abzumelden:

Web

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

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

Mit JavaScript über GitHub authentifizieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.