Google is committed to advancing racial equity for Black communities. See how.
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Uwierzytelnij się za pomocą Apple z JavaScript

Możesz pozwolić swoim użytkownikom na uwierzytelnianie w Firebase przy użyciu ich identyfikatora Apple ID, używając pakietu SDK Firebase do pełnego logowania OAuth 2.0.

Zanim zaczniesz

Aby logować użytkowników za pomocą Apple, najpierw skonfiguruj opcję Zaloguj się za pomocą Apple w witrynie programistów Apple, a następnie włącz Apple jako dostawcę logowania do projektu Firebase.

Dołącz do programu Apple Developer

Logowanie za pomocą Apple może być skonfigurowane tylko przez członków programu Apple Developer Program .

Skonfiguruj logowanie za pomocą Apple

W witrynie Apple Developer wykonaj następujące czynności:

  1. Skojarz swoją witrynę internetową z aplikacją zgodnie z opisem w pierwszej sekcji Konfiguruj logowanie za pomocą Apple dla sieci Web . Po wyświetleniu monitu zarejestruj następujący adres URL jako zwrotny adres URL:

    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler

    Możesz uzyskać identyfikator projektu Firebase na stronie ustawień konsoli Firebase .

    Kiedy skończysz, zanotuj swój nowy identyfikator usługi, którego będziesz potrzebować w następnej sekcji.

  2. Utwórz logowanie za pomocą klucza prywatnego Apple . W następnej sekcji będziesz potrzebować nowego klucza prywatnego i identyfikatora klucza.
  3. Jeśli korzystasz z którejkolwiek z funkcji uwierzytelniania Firebase, które wysyłają wiadomości e-mail do użytkowników, w tym logowania za pomocą łącza e-mail, weryfikacji adresu e-mail, odwołania zmiany konta i innych, skonfiguruj prywatną usługę przekazywania poczty e-mail Apple i zarejestruj się noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com (lub niestandardowej domeny szablonu wiadomości e-mail), aby firma Apple mogła przekazywać wiadomości e-mail wysyłane przez uwierzytelnianie Firebase na anonimowe adresy e-mail Apple.

Włącz Apple jako dostawcę logowania

  1. Dodaj Firebase do swojego projektu .
  2. W konsoli Firebase otwórz sekcję Uwierzytelnianie . Na karcie Metoda logowania włącz dostawcę Apple . Określ identyfikator usługi utworzony w poprzedniej sekcji. Ponadto w sekcji konfiguracji przepływu kodu OAuth określ swój identyfikator zespołu Apple oraz klucz prywatny i identyfikator klucza utworzony w poprzedniej sekcji.

Przestrzegaj wymagań Apple dotyczących anonimowych danych

Sign In with Apple daje użytkownikom możliwość anonimizacji ich danych, w tym adresu e-mail, podczas logowania. Użytkownicy, którzy wybiorą tę opcję, mają adresy e-mail w domenie privaterelay.appleid.com . Korzystając z funkcji Zaloguj się za pomocą Apple w swojej aplikacji, musisz przestrzegać wszelkich obowiązujących zasad lub warunków dla programistów firmy Apple dotyczących tych anonimowych identyfikatorów Apple ID.

Obejmuje to uzyskanie wymaganej zgody użytkownika przed powiązaniem jakichkolwiek danych osobowych umożliwiających bezpośrednią identyfikację z anonimowym identyfikatorem Apple ID. W przypadku korzystania z uwierzytelniania Firebase może to obejmować następujące działania:

  • Połącz adres e-mail z anonimowym identyfikatorem Apple ID lub odwrotnie.
  • Połącz numer telefonu z anonimowym identyfikatorem Apple ID lub odwrotnie
  • Połącz nieanonimowe dane logowania społecznościowego (Facebook, Google itp.) Z anonimowym identyfikatorem Apple ID lub odwrotnie.

Powyższa lista nie jest wyczerpująca. Zapoznaj się z umową licencyjną programu Apple Developer w sekcji Członkostwo na koncie programisty, aby upewnić się, że aplikacja spełnia wymagania Apple.

Obsługuj proces logowania za pomocą pakietu Firebase SDK

Jeśli tworzysz aplikację internetową, najłatwiejszym sposobem uwierzytelniania użytkowników w Firebase przy użyciu ich kont Apple jest obsługa całego procesu logowania za pomocą pakietu Firebase JavaScript SDK.

Aby obsłużyć proces logowania za pomocą pakietu Firebase JavaScript SDK, wykonaj następujące kroki:

  1. Utwórz wystąpienie dostawcy OAuthProvider, używając odpowiedniego identyfikatora dostawcy apple.com .

    var provider = new firebase.auth.OAuthProvider('apple.com');
  2. Opcjonalnie: określ dodatkowe zakresy OAuth 2.0 poza domyślne, których chcesz zażądać od dostawcy uwierzytelniania.

    provider.addScope('email');
    provider.addScope('name');

    Domyślnie, gdy włączone jest jedno konto na adres e-mail , Firebase żąda zakresów adresów e- mail i nazw. Jeśli zmienisz to ustawienie na Wiele kont na adres e-mail , Firebase nie będzie żądać od Apple żadnych zakresów, chyba że je określisz.

  3. Opcjonalnie: jeśli chcesz wyświetlić ekran logowania Apple w języku innym niż angielski, ustaw parametr locale . Zobacz dokumentację Logowanie za pomocą Apple, aby poznać obsługiwane języki.

    provider.setCustomParameters({
      // Localize the Apple authentication screen in French.
      locale: 'fr'
    });
  4. Uwierzytelnij się w Firebase przy użyciu obiektu dostawcy OAuth. Możesz poprosić użytkowników o zalogowanie się przy użyciu ich kont Apple, otwierając wyskakujące okienko lub przekierowując na stronę logowania. Metoda przekierowania jest preferowana na urządzeniach mobilnych.

    • Aby zalogować się za pomocą wyskakującego okienka, wywołaj signInWithPopup() :

      firebase
        .auth()
        .signInWithPopup(provider)
        .then((result) => {
          /** @type {firebase.auth.OAuthCredential} */
          var credential = result.credential;
      
          // The signed-in user info.
          var user = result.user;
      
          // You can also get the Apple OAuth Access and ID Tokens.
          var accessToken = credential.accessToken;
          var idToken = credential.idToken;
      
          // ...
        })
        .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;
      
          // ...
        });
    • Aby zalogować się przez przekierowanie do strony logowania, wywołaj signInWithRedirect() :

      firebase.auth().signInWithRedirect(provider);

      Gdy użytkownik ukończy logowanie i powróci do strony, możesz uzyskać wynik logowania, wywołując getRedirectResult() :

      // Result from Redirect auth flow.
      firebase
        .auth()
        .getRedirectResult()
        .then((result) => {
          if (result.credential) {
            /** @type {firebase.auth.OAuthCredential} */
            var credential = result.credential;
      
            // You can get the Apple OAuth Access and ID Tokens.
            var accessToken = credential.accessToken;
            var idToken = credential.idToken;
      
            // ...
          }
          // The signed-in user info.
          var user = result.user;
        })
        .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;
      
          // ...
        });

      W tym miejscu możesz również wyłapać i obsłużyć błędy. Lista kodów błędów znajduje się w dokumentacji interfejsu API .

    W przeciwieństwie do innych dostawców obsługiwanych przez Firebase Auth, Apple nie udostępnia adresu URL zdjęcia.

    Ponadto, gdy użytkownik zdecyduje się nie udostępniać swojego adresu e-mail aplikacji, Apple zapewnia mu unikatowy adres e-mail (w postaci xyz@privaterelay.appleid.com ), który udostępnia Twojej aplikacji. Jeśli skonfigurowałeś prywatną usługę przekazywania poczty e-mail, Apple przekazuje wiadomości e-mail wysłane na anonimowy adres na rzeczywisty adres e-mail użytkownika.

    Apple udostępnia aplikacjom informacje o użytkowniku, takie jak nazwa wyświetlana, tylko przy pierwszym logowaniu użytkownika. Zwykle Firebase przechowuje nazwę wyświetlaną przy pierwszym firebase.auth().currentUser.displayName użytkownika w Apple, którą można uzyskać za pomocą firebase.auth().currentUser.displayName . Jeśli jednak wcześniej używałeś Apple do logowania użytkownika do aplikacji bez korzystania z Firebase, Apple nie udostępni Firebase wyświetlanej nazwy użytkownika.

Ponowne uwierzytelnienie i łączenie kont

Tego samego wzorca można użyć z reauthenticateWithPopup() i reauthenticateWithRedirect() , których można użyć do pobrania nowego poświadczenia dla poufnych operacji, które wymagają niedawnego logowania:

const provider = new firebase.auth.OAuthProvider('apple.com');

firebase
  .auth()
  .currentUser
  .reauthenticateWithPopup(provider)
  .then((result) => {
    // User is re-authenticated with fresh tokens minted and can perform
    // sensitive operations like account deletion, or updating their email
    // address or password.
    /** @type {firebase.auth.OAuthCredential} */
    var credential = result.credential;

    // The signed-in user info.
    var user = result.user;
     // You can also get the Apple OAuth Access and ID Tokens.
    var accessToken = credential.accessToken;
    var idToken = credential.idToken;

    // ...
  })
  .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;

    // ...
  });

Możesz też użyć linkWithPopup() i linkWithRedirect() , aby połączyć różnych dostawców tożsamości z istniejącymi kontami.

Pamiętaj, że Apple wymaga uzyskania wyraźnej zgody od użytkowników przed połączeniem ich kont Apple z innymi danymi.

Na przykład, aby połączyć konto na Facebooku z bieżącym kontem Firebase, użyj tokena dostępu, który otrzymałeś podczas logowania użytkownika na Facebooku:

const provider = new firebase.auth.FacebookAuthProvider();
provider.addScope('user_birthday');

// Assuming the current user is an Apple user linking a Facebook provider.
firebase.auth().currentUser.linkWithPopup(provider)
    .then((result) => {
      // Facebook credential is linked to the current Apple user.
      // Facebook additional data available in result.additionalUserInfo.profile,

      // Additional Facebook OAuth access token can also be retrieved.
      // result.credential.accessToken

      // The user can now sign in to the same account
      // with either Apple or Facebook.
    })
    .catch((error) => {
      // Handle error.
    });

Uwierzytelnij się w Firebase w rozszerzeniu do Chrome

Jeśli tworzysz rozszerzenie do Chrome, musisz dodać swój identyfikator rozszerzenia do Chrome:

  1. Otwórz projekt w konsoli Firebase .
  2. W sekcji Uwierzytelnianie otwórz stronę Metoda logowania .
  3. Dodaj identyfikator URI podobny do poniższego do listy autoryzowanych domen:
    chrome-extension://CHROME_EXTENSION_ID

Tylko operacje wyskakujących okienek ( signInWithPopup i linkWithPopup ) są dostępne dla rozszerzeń Chrome, ponieważ rozszerzenia Chrome nie mogą używać przekierowań HTTP. Powinieneś wywoływać te metody ze skryptu działającego w tle, a nie z wyskakującego okienka akcji przeglądarki, ponieważ wyskakujące okienko uwierzytelniania anuluje wyskakujące okienko akcji przeglądarki.

W pliku manifestu rozszerzenia Chrome upewnij się, że dodajesz adres URL https://apis.google.com do allowlist content_security_policy .

Pamiętaj, że nadal musisz zweryfikować domenę niestandardową w Apple, podobnie jak w przypadku domyślnej domeny firebaseapp.com:

http://auth.custom.example.com/.well-known/apple-developer-domain-association.txt

Zaawansowane: uwierzytelnij się w Firebase w Node.js.

Aby uwierzytelnić się w Firebase w aplikacji Node.js:

  1. Zaloguj użytkownika za pomocą jego konta Apple i uzyskaj token Apple ID użytkownika. Możesz to osiągnąć na kilka sposobów. Na przykład, jeśli Twoja aplikacja Node.js ma interfejs przeglądarki:

    1. Na swoim zapleczu wygeneruj losowy ciąg („nonce”) i oblicz jego hash SHA256. Wartość jednorazowa to jednorazowa wartość używana do weryfikacji pojedynczej podróży w obie strony między zapleczem a serwerami autoryzacji Apple.

      const crypto = require("crypto");
      const string_decoder = require("string_decoder");
      
      // Generate a new random string for each sign-in
      const generateNonce = function(length) {
        const decoder = new string_decoder.StringDecoder("ascii");
        const buf = Buffer.alloc(length);
        var nonce = "";
        while (nonce.length < length) {
          crypto.randomFillSync(buf);
          nonce = decoder.write(buf);
        }
        return nonce.substr(0, length);
      };
      
      const unhashedNonce = generateNonce(10);
      
      // SHA256-hashed nonce in hex
      const hashedNonceHex = crypto.createHash('sha256')
        .update(unhashedNonce).digest().toString('hex');
    2. Na stronie logowania określ zaszyfrowany numer jednorazowy w konfiguracji logowania się przez Apple:

      <script src="https://appleid.cdn-apple.com/appleauth/static/jsapi/appleid/1/en_US/appleid.auth.js"></script>
      <div id="appleid-signin" data-color="black" data-border="true" data-type="sign in"></div>
      <script>
          AppleID.auth.init({
              clientId: YOUR_APPLE_CLIENT_ID,
              scope: 'name email',
              redirectURI: URL_TO_YOUR_REDIRECT_HANDLER,  // See the next step.
              state: '[STATE]',  // Optional value that Apple will send back to you
                                 // so you can return users to the same context after
                                 // they sign in.
              nonce: HASHED_NONCE  // The hashed nonce you generated in the previous step.
          });
      </script>
      
    3. Uzyskaj token Apple ID ze strony serwera odpowiedzi uwierzytelniającej POST:

      app.post('/redirect', (req, res) => {
        const savedState = req.cookies.__session;
        const code = req.body.code;
        const state = req.body.state;
        const appleIdToken = req.body.id_token;
        if (savedState !== state || !code) {
          res.status(403).send('403: Permission denied');
        } else {
          // Sign in with Firebase using appleIdToken. (See next step).
        }
      });
      

    Zobacz także Konfigurowanie strony internetowej do logowania się za pomocą Apple .

  2. Po uzyskaniu tokena Apple ID użytkownika użyj go do zbudowania obiektu Credential, a następnie zaloguj się za pomocą poświadczeń:

    // Build Firebase credential with the Apple ID token.
    const provider = new firebase.auth.OAuthProvider('apple.com');
    const authCredential = provider.credential({
      idToken: appleIdToken,
      rawNonce: unhashedNonce,
    });
    
    // Sign in with credential form the Apple user.
    firebase.auth().signInWithCredential(authCredential)
      .then((result) => {
        // User signed in.
      })
      .catch((error) => {
        // An error occurred. If error.code == 'auth/missing-or-invalid-nonce',
        // make sure you're sending the SHA256-hashed nonce as a hex string
        // with your request to Apple.
        console.log(error);
      });

Następne kroki

Gdy użytkownik loguje się po raz pierwszy, tworzone jest nowe konto użytkownika i jest ono łączone z poświadczeniami - to jest z nazwą użytkownika i hasłem, numerem telefonu lub informacjami dostawcy uwierzytelniania - zalogowanym użytkownikiem. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikacji użytkownika we wszystkich aplikacjach w Twoim projekcie, niezależnie od tego, w jaki sposób się on zaloguje.

  • W aplikacjach zalecanym sposobem poznania statusu Auth użytkownika jest ustawienie obserwatora na obiekcie Auth . Następnie możesz uzyskać podstawowe informacje o profilu User obiektu User . Zobacz Zarządzanie użytkownikami .

  • W Firebase Realtime Database i Cloud Storage Rules możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.

Aby wylogować użytkownika, wywołaj signOut :

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