Sprawdzanie aplikacji Firebase na platformach Apple

1. Wprowadzenie

Sprawdzanie aplikacji Firebase pomaga chronić zasoby backendu przed nadużyciami takimi jak oszustwa związane z płatnościami czy wyłudzanie informacji, pilnując, aby żądania pochodziły z dozwolonych aplikacji i urządzeń. Współpracuje z usługami Firebase oraz z Twoimi własnymi usługami backendu, aby zapewnić bezpieczeństwo Twoich zasobów.

Więcej informacji o Sprawdzaniu aplikacji Firebase znajdziesz w dokumentacji Firebase.

Sprawdzanie aplikacji korzysta z usług działających na określonej platformie, aby weryfikować integralność aplikacji lub urządzenia. Takie usługi są nazywane dostawcami atestów. Jednym z takich dostawców jest usługa App Attest firmy Apple, która służy do weryfikowania autentyczności aplikacji i urządzeń Apple.

Co utworzysz

W ramach tego ćwiczenia w Codelabs dodasz i wymusisz sprawdzanie aplikacji w istniejącej przykładowej aplikacji, aby chronić bazę danych czasu rzeczywistego projektu przed dostępem niedozwolonych aplikacji i urządzeń.

Czego się nauczysz

• Jak dodać Sprawdzanie aplikacji Firebase do istniejącej aplikacji.
• Instalowanie różnych dostawców atestów Sprawdzania aplikacji Firebase.
• Jak skonfigurować App Attest dla aplikacji.
• Jak skonfigurować dostawcę poświadczania debugowania, aby testować aplikację w symulatorach podczas jej tworzenia.

Czego potrzebujesz

• Xcode 13.3.1 lub nowsza wersja
• konto dewelopera Apple, które umożliwia tworzenie nowych identyfikatorów aplikacji.
• Urządzenie z iOS lub iPadOS obsługujące App Attest (dowiedz się więcej o dostępności interfejsu App Attest API).

Uwaga: to ćwiczenie z programowania możesz wykonać bez konta dewelopera Apple i odpowiedniego urządzenia. W takim przypadku aplikację będzie można uruchomić tylko w symulatorze, który korzysta z dostawcy debugowania Sprawdzania aplikacji Firebase.

2. Pobieranie projektu startowego

Repozytorium Firebase Quickstarts for iOS zawiera przykładowe aplikacje do zaprezentowania różnych usług Firebase. W ramach tego ćwiczenia z programowania wykorzystasz aplikację Baza danych Firebase z krótkim wprowadzeniem do interfejsu SwiftUI.

Skopiuj repozytorium Firebase z krótkimi przewodnikami na iOS z wiersza poleceń:

git clone https://github.com/firebase/quickstart-ios.git
cd quickstart-ios

Otwórz projekt aplikacji Realtime Database SwiftUI z krótkim wprowadzeniem w Xcode:

cd database/DatabaseExampleSwiftUI/DatabaseExample
xed .

3. Dodaj Sprawdzanie aplikacji do swojej aplikacji

1. Poczekaj, aż menedżer pakietów Swift rozwinie zależności projektu.
2. Otwórz kartę Ogólne w miejscu docelowym aplikacji DatabaseExample (iOS). Następnie w sekcji Ramki, biblioteki i umieszczone treści kliknij przycisk +.
3. Wybierz, aby dodać FirebaseAppCheck.

4. Utwórz i zainstaluj fabrykę dostawcy Sprawdzania aplikacji

1. Do grupy plików Shared dodaj nową grupę o nazwie AppCheck.
2. W tej grupie utwórz klasę fabryczną w osobnym pliku, np. MyAppCheckProviderFactory.swift , pamiętaj o dodaniu go do celu DatabaseExample (iOS):

   import Firebase
   
   class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
     func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
       #if targetEnvironment(simulator)
         // App Attest is not available on simulators.
         // Use a debug provider.
         return AppCheckDebugProvider(app: app)
       #else
         // Use App Attest provider on real devices.
         return AppAttestProvider(app: app)
       #endif
     }
   }
   

3. Następnie w: DatabaseExampleApp.swift zaimportuj FirebaseAppCheck i ustaw instancję klasy MyAppCheckProviderFactory jako fabrykę dostawcy Sprawdzania aplikacji.

   import SwiftUI
   import FirebaseCore
   import FirebaseAppCheck
   
   @main
   struct DatabaseExampleApp: App {
     init() {
       // Set an instance of MyAppCheckProviderFactory as an App Check
       // provider factory before configuring Firebase.
       AppCheck.setAppCheckProviderFactory(MyAppCheckProviderFactory())
       FirebaseApp.configure()
     }
     ...
   }
   

5. Tworzenie i konfigurowanie projektu Firebase

Aby użyć Sprawdzania aplikacji w projekcie iOS, wykonaj w konsoli Firebase te czynności:

• skonfigurować projekt Firebase,
• Dodaj swoją aplikację na iOS do projektu Firebase.
• Skonfiguruj Uwierzytelnianie Firebase.
• Zainicjuj instancję Bazy danych czasu rzeczywistego, którą chcesz chronić.
• Skonfiguruj Sprawdzanie aplikacji.

Utwórz projekt

Najpierw musisz utworzyć projekt Firebase.

1. W konsoli Firebase kliknij Dodaj projekt.
2. Nazwij swój projekt App Check Codelab
3. Kliknij Dalej.
4. Wyłącz Google Analytics w tym projekcie, a następnie kliknij Utwórz projekt.

Tworzenie instancji bazy danych czasu rzeczywistego

Przejdź teraz do sekcji Baza danych czasu rzeczywistego w konsoli Firebase.

1. Kliknij przycisk Utwórz bazę danych, aby rozpocząć przepływ pracy tworzenia bazy danych.
2. Pozostaw domyślną lokalizację bazy danych (us-central1) bez zmian i kliknij Dalej.
3. Wybierz Tryb blokady i kliknij przycisk Włącz, aby włączyć reguły zabezpieczeń dla bazy danych.
4. W przeglądarce Baza danych czasu rzeczywistego otwórz kartę Reguły i zastąp reguły domyślne tymi:

   {
       "rules": {
           // User profiles are only readable/writable by the user who owns it
           "users": {
               "$UID": {
                   ".read": "auth.uid == $UID",
                   ".write": "auth.uid == $UID"
               }
           },
           // Posts can be read by anyone but only written by logged-in users.
           "posts": {
               ".read": true,
               ".write": "auth.uid != null",
               "$POSTID": {
                   // UID must match logged in user and is fixed once set
                   "uid": {
                       ".validate": "(data.exists() && data.val() == newData.val()) || newData.val() == auth.uid"
                   },
                   // User can only update own stars
                   "stars": {
                       "$UID": {
                           ".validate": "auth.uid == $UID"
                       }
                   }
               }
           },
           // User posts can be read by anyone but only written by the user that owns it,
           // and with a matching UID
           "user-posts": {
               ".read": true,
               "$UID": {
                   "$POSTID": {
                       ".write": "auth.uid == $UID",
                       ".validate": "data.exists() || newData.child('uid').val() == auth.uid"
                   }
               }
           },
           // Comments can be read by anyone but only written by a logged in user
           "post-comments": {
               ".read": true,
               ".write": "auth.uid != null",
               "$POSTID": {
                   "$COMMENTID": {
                       // UID must match logged in user and is fixed once set
                       "uid": {
                           ".validate": "(data.exists() && data.val() == newData.val()) || newData.val() == auth.uid"
                       }
                   }
               }
           }
       }
   }
   

5. Kliknij przycisk Opublikuj, aby aktywować zaktualizowane reguły zabezpieczeń.

Przygotowywanie aplikacji na iOS do połączenia z Firebase

Aby móc uruchomić przykładową aplikację na urządzeniu fizycznym, musisz dodać projekt do zespołu programistów. Dzięki temu Xcode będzie mógł zarządzać wymaganym profilem udostępniania. Aby dodać przykładową aplikację do konta dewelopera, wykonaj te czynności:

1. W Xcode w nawigatorze projektów wybierz projekt DatabaseExample.
2. Wybierz środowisko docelowe DatabaseExample (iOS) i otwórz okno Signing & Pozwolenia.
3. Powinien wyświetlić się komunikat o błędzie: „Do zalogowania się w usłudze DatabaseExample (iOS) wymagany jest zespół programistów”.
4. Zmień identyfikator pakietu na unikalny identyfikator. Najłatwiej to zrobić, używając odwrotnej nazwy domeny witryny, np. com.acme.samples.firebase.quickstart.DatabaseExample (nie używaj tego identyfikatora – zamiast tego wybierz własny, unikalny identyfikator).
5. Wybierz zespół programistów.
6. Gdy Xcode wyświetli komunikat „Obsługa administracyjna: profil zarządzany Xcode”, oznacza to, że wszystko poszło dobrze. i niewielką ikonę informacji obok tej etykiety. Kliknięcie tej ikony spowoduje wyświetlenie dodatkowych informacji o profilu obsługi administracyjnej.

Ważne: jeśli nie podasz unikalnego identyfikatora pakietu, projekt nie zostanie zarejestrowany w portalu Apple dla deweloperów. Na urządzeniu fizycznym można uruchamiać tylko zarejestrowane aplikacje.

Połącz aplikację na iOS

Dokładniejsze informacje o łączeniu aplikacji znajdziesz w dokumentacji dotyczącej dodawania Firebase do projektu na iOS. Aby rozpocząć, wykonaj te główne czynności w konsoli Firebase:

1. Na ekranie Przegląd projektu nowego projektu kliknij kolejno przycisk + Dodaj aplikację i ikonę iOS+, aby dodać do projektu Firebase nową aplikację na iOS.
2. Podaj identyfikator pakietu aplikacji (użyj identyfikatora zdefiniowanego w poprzedniej sekcji, np. com.acme.samples.firebase.quickstart.DatabaseExample – pamiętaj, że musi to być unikalny identyfikator)
3. Kliknij Zarejestruj aplikację.
4. Firebase generuje plik GoogleService-Info.plist zawierający wszystkie metadane Firebase niezbędne dla Twojej aplikacji.
5. Kliknij Download GoogleService-Info.plist, aby pobrać plik.
6. W Xcode zobaczysz, że projekt zawiera już plik o nazwie GoogleService-Info.plist. Najpierw usuń ten plik – w następnym kroku zastąpisz go plikiem powiązanym z Twoim projektem Firebase.
7. Skopiuj plik GoogleService-Info.plist pobrany w poprzednim kroku do folderu głównego projektu Xcode i dodaj go do miejsca docelowego DatabaseExample (iOS), upewniając się, że ma nazwę GoogleService-Info.plist
8. Wykonaj pozostałe kroki procedury rejestracji. Przykładowy projekt jest już prawidłowo skonfigurowany, więc nie musisz wprowadzać żadnych zmian w kodzie.

Skonfiguruj Uwierzytelnianie Firebase

Uff... To już całkiem sporo, ale cierpliwie! Jeśli dopiero zaczynasz korzystać z Firebase, znasz już podstawowe elementy przepływu pracy, które już wkrótce będą Ci dobrze znane.

Teraz skonfigurujesz Uwierzytelnianie Firebase dla tej aplikacji.

Włącz dostawcę logowania za pomocą adresu e-mail/hasła

1. Pozostając w konsoli Firebase, otwórz sekcję Uwierzytelnianie.
2. Kliknij Rozpocznij, aby skonfigurować Uwierzytelnianie Firebase w swoim projekcie.
3. Wybierz kartę Metoda logowania.
4. W sekcji Dostawcy reklam natywnych wybierz E-mail/hasło.
5. Włącz opcje E-mail/hasło i kliknij Zapisz.

Dodawanie użytkownika testowego

1. Otwórz kartę Users (Użytkownicy) w sekcji Authentication (Uwierzytelnianie).
2. Kliknij Dodaj użytkownika.
3. Wpisz adres e-mail i hasło użytkownika testowego, a następnie kliknij Dodaj użytkownika.

Wypróbuj aplikację

Wróć do Xcode i uruchom aplikację w symulatorze iOS. Zaloguj się za pomocą adresu e-mail i hasła utworzonego przed chwilą testowego użytkownika. Po zalogowaniu się możesz utworzyć posta, dodać komentarz do istniejącego posta i oznaczyć go gwiazdką lub usunąć oznaczenie gwiazdką.

6. Konfigurowanie dostawcy atestu aplikacji

W tym kroku skonfigurujesz Sprawdzanie aplikacji tak, aby używało dostawcy App Attest w konsoli Firebase.

1. W konsoli Firebase przejdź do sekcji Sprawdzanie aplikacji.
2. Kliknij Rozpocznij.
3. Na karcie Aplikacje kliknij aplikację, aby rozwinąć jej szczegóły.
4. Kliknij App Attest, aby skonfigurować App Attest, a następnie wpisz identyfikator zespołu powiązany z kontem dewelopera Apple (możesz go znaleźć w sekcji Membership w portalu Apple Developer):
5. Kliknij Zapisz.

Oznacza to, że masz działający projekt Firebase połączony z naszą nową aplikacją z włączonym Sprawdzaniem aplikacji.

Możesz teraz skonfigurować naszą konkretną usługę atestu. Więcej informacji o tym przepływie pracy znajdziesz w artykule Włączanie Sprawdzania aplikacji za pomocą App Attest na urządzeniach z iOS.

7. Skonfiguruj App Attest dla swojej aplikacji

Nadszedł czas, aby zapoznać się z pakietem SDK Sprawdzania aplikacji Firebase i wdrożyć kod klienta.

Najpierw musisz skonfigurować projekt Xcode tak, aby pakiet SDK mógł używać interfejsu App Attest API firmy Apple i mieć pewność, że żądania wysyłane z Twojej aplikacji pochodzą z dozwolonych jej instancji.

1. Dodaj funkcję App Attest dla miejsca docelowego aplikacji w projekcie Xcode:
2. otwórz menu Signing & kartę „Możliwości” w ustawieniach miejsca docelowego aplikacji.
3. kliknij przycisk „+” przycisk
4. w oknie znajdź i wybierz funkcję App Attest .
5. Po wykonaniu poprzedniego kroku w folderze głównym projektu Xcode pojawi się plik DatabaseExample (iOS).entitlements.
6. W pliku DatabaseExample (iOS).entitlements zmień wartość klucza App Attest Environment na production.

Ważne: obecnie Sprawdzanie aplikacji Firebase obsługuje dostawcę App Attest tylko wtedy, gdy jest on w trybie produkcyjnym. Domyślnie, gdy uruchamiasz aplikację z Xcode, App Attest działa w trybie piaskownicy lub trybie programowania, więc aby przełączyć tryb App Attest, wykonaj podane wyżej czynności. w przeciwnym razie Sprawdzanie aplikacji Firebase nie przeprowadzi poświadczania urządzenia.

Gdy wykonasz te czynności i uruchomisz aplikację na fizycznym urządzeniu z iOS (iPhone/iPad), będzie ona nadal miała dostęp do Bazy danych czasu rzeczywistego. W jednym z późniejszych kroków wybierzesz wymuszenie Sprawdzania aplikacji, które zablokuje wysyłanie żądań z nieprawidłowych aplikacji i urządzeń.

Więcej informacji o tym przepływie pracy znajdziesz w artykule Włączanie Sprawdzania aplikacji za pomocą App Attest na urządzeniach z iOS.

8. Konfigurowanie dostawcy atestu debugowania na potrzeby symulatora iOS

Dostawca Debugowania Sprawdzania aplikacji Firebase umożliwia testowanie aplikacji z wymuszaniem Sprawdzania aplikacji Firebase w niezaufanych środowiskach, w tym w symulatorze iOS, podczas programowania. Następnie musisz wspólnie skonfigurować dostawcę debugowania.

Ostrzeżenie: dostawca debugowania umożliwia dostęp do zasobów Firebase z niezweryfikowanych urządzeń. Nigdy nie należy korzystać z dostawcy debugowania w kompilacjach produkcyjnych aplikacji. Uważaj też, aby nie ujawnić swojego tokena debugowania.

Instalowanie w aplikacji dostawcy debugowania Firebase

Opcja 1. Warunkowe utworzenie instancji dostawcy debugowania w fabryce

Większość tych czynności została wykonana podczas tworzenia fabryki dostawcy Sprawdzania aplikacji. W tym kroku dodasz logowanie lokalnego tajnego klucza debugowania wygenerowanego przez dostawcę debugowania, co pozwoli Ci zarejestrować tę instancję aplikacji w konsoli Firebase na potrzeby debugowania.

Zaktualizuj aplikację MyAppCheckProviderFactory.swift, podając ten kod:

import Firebase

class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
  func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
#if targetEnvironment(simulator)
    // App Attest is not available on simulators.
    // Use a debug provider.
    let provider = AppCheckDebugProvider(app: app)

    // Print only locally generated token to avoid a valid token leak on CI.
    print("Firebase App Check debug token: \(provider?.localDebugToken() ?? "" )")

    return provider
#else
    // Use App Attest provider on real devices.
    return AppAttestProvider(app: app)
#endif
  }
}

To podejście daje nam większą elastyczność konfigurowania Sprawdzania aplikacji w zależności od środowiska. Na przykład w systemach operacyjnych, w których usługa App Attest jest niedostępna, możesz korzystać z innych dostawców poświadczeń, takich jak DeviceCheck lub niestandardowego dostawcy atestów. Oto przykład:

import Firebase

class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
  func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
      #if targetEnvironment(simulator)
      // App Attest is not available on simulators.
      // Use a debug provider.
      let provider = AppCheckDebugProvider(app: app)

      // Print only locally generated token to avoid a valid token leak on CI.
      print("Firebase App Check debug token: \(provider?.localDebugToken() ?? "" )")

      return provider
      #else
      if #available(iOS 14.0, *) {
        // Use App Attest provider on real devices.
        return AppAttestProvider(app: app)
      } else {
        return DeviceCheckProvider(app: app)
      }
      #endif
  }
}

Opcja 2. Zainstaluj AppCheckDebugProviderFactory

W prostszych przypadkach możesz tymczasowo lub warunkowo zainstalować AppCheckDebugProviderFactory, zanim skonfigurujesz instancję aplikacji Firebase:

init() {
#if targetEnvironment(simulator)
  let providerFactory = AppCheckDebugProviderFactory()
#else
  let providerFactory = MyAppCheckProviderFactory()
#endif

  AppCheck.setAppCheckProviderFactory(providerFactory)

  FirebaseApp.configure()
}

Pozwoli Ci to zaoszczędzić kilka linijek kodu podczas tworzenia własnej fabryki dostawcy Sprawdzania aplikacji.

Rejestrowanie obiektu tajnego debugowania w konsoli Firebase

Uzyskiwanie obiektu tajnego debugowania z symulatora iOS

1. Jeśli zdecydujesz się zainstalować aplikację AppCheckDebugProviderFactory (opcja 2 powyżej), musisz włączyć logowanie debugowania aplikacji, dodając -FIRDebugEnabled do argumentów uruchomienia aplikacji:
2. Uruchamianie aplikacji w symulatorze
3. Znajdź tajny klucz debugowania w konsoli Xcode. Aby szybciej je znaleźć, możesz użyć filtra konsoli:

Uwaga: tajny klucz debugowania jest generowany dla symulatora przy pierwszym uruchomieniu aplikacji i zapisywany w wartościach domyślnych użytkownika. Jeśli usuniesz aplikację, zresetujesz symulator lub użyjesz innego symulatora, zostanie wygenerowany nowy tajny klucz debugowania. Pamiętaj, aby zarejestrować nowy tajny klucz debugowania.

Rejestrowanie obiektu tajnego debugowania

1. Wróć do sekcji Sprawdzanie aplikacji w konsoli Firevbase.
2. Na karcie Aplikacje kliknij aplikację, aby rozwinąć jej szczegóły.
3. W rozszerzonym menu wybierz Zarządzaj tokenami debugowania:
4. Dodaj obiekt tajny skopiowany z konsoli Xcode, a następnie kliknij Zapisz .

Po wykonaniu tych czynności możesz używać aplikacji w symulatorze nawet przy wymuszonym sprawdzaniu aplikacji.

Uwaga: dostawca debugowania został zaprojektowany tak, aby ułatwić zapobieganie wyciekom obiektów tajnych debugowania. Przy obecnym podejściu nie musisz przechowywać tajnego klucza debugowania w kodzie źródłowym.

Więcej informacji na temat tego procesu znajdziesz w dokumentacji – przeczytaj artykuł o korzystaniu ze Sprawdzania aplikacji za pomocą dostawcy debugowania na urządzeniach z iOS.

9. Włącz wymuszanie Sprawdzania aplikacji w Bazie danych czasu rzeczywistego Firebase

Na razie nasza aplikacja deklaruje parametr AppCheckProviderFactory, który w przypadku prawdziwych urządzeń zwraca AppAttestProvider. Gdy aplikacja działa na urządzeniu fizycznym, przeprowadza atest i wysyła wyniki do backendu Firebase. Backend Firebase nadal akceptuje jednak żądania z dowolnego urządzenia, symulatora iOS, skrypt itp. Ten tryb jest przydatny, gdy nadal masz użytkowników korzystających ze starej wersji aplikacji bez Sprawdzania aplikacji i nie chcesz jeszcze wymuszać kontroli dostępu.

Teraz musisz włączyć wymuszanie Sprawdzania aplikacji, aby mieć pewność, że dostęp do aplikacji Firebase można uzyskiwać tylko z odpowiednich urządzeń. Gdy włączysz egzekwowanie w projekcie Firebase, stare wersje aplikacji bez integracji Sprawdzania aplikacji przestaną działać.

Uwaga: w przypadku działającej aplikacji, w której występują dotychczasowi użytkownicy, nie należy włączać wymuszania, chyba że masz pewność, że użytkownicy przeszli na nową wersję aplikacji, która może przejść test Sprawdzania aplikacji. Wszyscy prawdziwi użytkownicy korzystający ze starej aplikacji bez zintegrowanego Sprawdzania aplikacji utracą dostęp do bazy danych czasu rzeczywistego, nawet jeśli korzystają z niej na legalnych urządzeniach.

Aby przejście użytkowników przebiegło płynnie, zwykle musisz z wyprzedzeniem opublikować aplikację zintegrowaną z funkcją Sprawdzanie aplikacji i przez jakiś czas nie wymuszać używania projektu Firebase. Dane dotyczące żądań Sprawdzania aplikacji dostępne w konsoli Firebase mogą pomóc Ci zdecydować, kiedy należy włączyć wymuszanie.

1. W konsoli Firebase w sekcji Sprawdzanie aplikacji kliknij Baza danych czasu rzeczywistego, aby rozwinąć jej szczegóły.
2. Kliknij Egzekwuj.

3. Przeczytaj informacje w oknie potwierdzenia i kliknij Egzekwuj.

Po wykonaniu tych czynności dostęp do bazy danych będą mogły uzyskać tylko uprawnione aplikacje. Pozostałe aplikacje zostaną zablokowane.

Spróbuj uzyskać dostęp do Bazy danych czasu rzeczywistego za pomocą nielegalnej aplikacji

Aby zobaczyć, jak wygląda egzekwowanie zasad Sprawdzania aplikacji, wykonaj te czynności:

1. Wyłącz rejestrację w Sprawdzaniu aplikacji, komentując kod rejestracji Sprawdzania aplikacji w metodzie init punktu wejścia aplikacji w DatabaseExampleApp.
2. Zresetuj symulator, wybierając Urządzenie > Usuń całą zawartość i ustawienia. Spowoduje to wyczyszczenie symulatora (i unieważnienie tokena urządzenia).
3. Uruchom ponownie aplikację w symulatorze.
4. Powinien wyświetlić się następujący komunikat o błędzie:

   [FirebaseDatabase][I-RDB034005] Firebase Database connection was forcefully killed by the server.  Will not attempt reconnect. Reason: Invalid appcheck token.
   

Aby ponownie włączyć Sprawdzanie aplikacji:

1. Usuń znacznik komentarza z kodu rejestracyjnego Sprawdzania aplikacji w DatabaseExampleApp.
2. Ponownie uruchom aplikację.
3. Zanotuj nowy token Sprawdzania aplikacji w konsoli Xcode.
4. Zarejestruj token debugowania w ustawieniach Sprawdzania aplikacji w konsoli Firebase.
5. Uruchom aplikację ponownie.
6. Komunikat o błędzie nie powinien się już wyświetlać. Możesz też dodawać nowe posty i komentarze w aplikacji.

10. Gratulacje!

Teraz wiesz już, jak:

• Dodaj Sprawdzanie aplikacji do istniejącego projektu
• Skonfiguruj dostawcę atestu aplikacji dla wersji produkcyjnej aplikacji
• Skonfiguruj dostawcę atestu debugowania, aby przetestować aplikację w symulatorze
• Obserwuj wdrażanie wersji aplikacji, aby dowiedzieć się, kiedy należy wymusić Sprawdzanie aplikacji w projekcie Firebase.
• Włącz wymuszanie Sprawdzania aplikacji

Następne kroki

W ramach stopniowego wdrażania Sprawdzania aplikacji Firebase za pomocą Zdalnej konfiguracji Firebase dowiesz się, jak używać Zdalnej konfiguracji do stopniowego wdrażania Sprawdzania aplikacji u użytkowników.

Oto inne materiały, które mogą Ci się przydać

Konfiguracja opisana w tym ćwiczeniu z programowania sprawdzi się w większości przypadków, ale Sprawdzanie aplikacji zapewnia większą elastyczność w razie potrzeby. Więcej informacji znajdziesz w tych linkach:

• Repozytorium Firebase z krótkimi przewodnikami na iOS
• Włączanie Sprawdzania aplikacji za pomocą App Attest w systemie iOS
• Sprawdzanie aplikacji Firebase w dokumentacji Firebase
• Dbanie o integralność aplikacji
• Rejestrowanie identyfikatora aplikacji
• Włączanie funkcji aplikacji