Ta strona została przetłumaczona przez Cloud Translation API.

Zabezpieczanie klucza interfejsu API za pomocą funkcji sprawdzania aplikacji

Sprawdzanie aplikacji Firebase zapewnia ochronę wywołań z Twojej aplikacji do Google Maps Platform, blokując ruch pochodzący z źródeł innych niż prawidłowe aplikacje. Robi to, sprawdzając token od dostawcy usługi weryfikacji, takiej jak App Attest. Integracja aplikacji ze Sprawdzaniem aplikacji pomaga chronić przed szkodliwymi żądaniami, dzięki czemu nie naliczamy opłat za nieautoryzowane wywołania interfejsu API.

Czy sprawdzanie aplikacji jest dla mnie odpowiednie?

W większości przypadków zalecamy użycie narzędzia App Check, ale w tych sytuacjach nie jest ono potrzebne lub nie jest obsługiwane:

Używasz oryginalnego pakietu SDK Miejsc. Sprawdzanie aplikacji jest obsługiwane tylko w przypadku pakietu SDK Miejsc (nowy).
Aplikacje prywatne lub eksperymentalne. Jeśli aplikacja nie jest dostępna publicznie, nie musi być sprawdzana.
Jeśli aplikacja jest używana tylko na serwerach, nie trzeba jej sprawdzać. Jeśli jednak serwer komunikujący się z GMP jest używany przez publicznych klientów (np. aplikacje mobilne), rozważ zastosowanie App Check do ochrony tego serwera zamiast GMP.
Zalecane przez App Check dostawcy usług weryfikacji nie będą działać na urządzeniach uznanych przez dostawcę za zagrożone lub niegodne zaufania. Jeśli chcesz obsługiwać takie urządzenia, możesz wdrożyć niestandardową usługę uwierzytelniania. Więcej informacji znajdziesz w instrukcjach.

Omówienie etapów wdrażania

Ogólnie rzecz biorąc, aby zintegrować aplikację z usługą App Check, musisz wykonać te czynności:

Dodaj Firebase do swojej aplikacji.
Dodaj i inicjuj bibliotekę AppCheck.
Dodaj dostawcę tokenów do aplikacji.
Inicjuj interfejsy API Miejsca i App Check.
Włącz debugowanie.
Sprawdzaj żądania aplikacji i decyduj o sposobie ich egzekwowania.

Po integracji z App Check możesz wyświetlać dane o ruchu w backendzie w konsoli Firebase. Te dane zawierają zestawienie żądań z podziałem na te, które mają prawidłowy token Sprawdzania aplikacji, i te, które go nie mają. Więcej informacji znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.

Gdy będziesz mieć pewność, że większość żądań pochodzi z wiarygodnych źródeł, a użytkownicy zaktualizowali aplikację do najnowszej wersji, która zawiera funkcję sprawdzania aplikacji, możesz włączyć egzekwowanie. Po włączeniu wymuszania Sprawdzanie aplikacji odrzuci cały ruch bez prawidłowego tokena Sprawdzania aplikacji.

Co wziąć pod uwagę podczas planowania integracji z App Check

Oto kilka kwestii, które warto wziąć pod uwagę podczas planowania integracji:

Zalecane przez nas dostawcy usług weryfikacji, Device Check lub App Attest, podlegają limitom i ograniczeniami określonymi przez Apple.
Możesz użyć niestandardowego dostawcy weryfikacji, ale jest to zaawansowany przypadek użycia. Więcej informacji znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.
Użytkownicy aplikacji będą odczuwać pewne opóźnienia podczas uruchamiania. Jednak później okresowe ponowne weryfikowanie będzie odbywać się w tle, a użytkownicy nie powinni już odczuwać żadnych opóźnień. Dokładna wartość opóźnienia na starcie zależy od wybranego dostawcy usługi weryfikacji.

Częstotliwość ponownych weryfikacji zależy od okresu ważności tokena Sprawdzania aplikacji (czasu życia danych, czyli TTL). Czas trwania można skonfigurować w konsoli Firebase. Ponowne potwierdzenie następuje po upływie około połowy czasu trwania. Więcej informacji znajdziesz w dokumentacji Firebase dotyczącej dostawcy atesta.

Integracja aplikacji z Sprawdzaniem aplikacji

Wymagania wstępne i wymagania

aplikacja z zainstalowanym pakietem SDK Miejsc w wersji 9.2 lub nowszej.
Identyfikator pakietu aplikacji.
Identyfikator zespołu z Apple Member Center w sekcji Membership (Członkostwo).
Jeśli planujesz korzystać z funkcji Device Check, musisz mieć plik klucza prywatnego i identyfikator klucza.
Musisz być właścicielem aplikacji w konsoli Cloud.
Potrzebujesz identyfikatora projektu aplikacji z konsoli Cloud.

Krok 1. Dodaj Firebase do swojej aplikacji

Aby dodać Firebase do aplikacji, wykonaj instrukcje w dokumentacji dla deweloperów Firebase.

Po zarejestrowaniu aplikacji otrzymasz plik konfiguracji GoogleService-Info.plist. Dodaj ten plik w niezmodyfikowanej formie na najwyższym poziomie aplikacji.

Uwaga: w kroku 5 dokumentacji dla deweloperów Firebase, w którym dodajesz do pliku AppDelegate moduły Firebase, dodaj te moduły:

Swift

import FirebaseCore
import FirebaseAppCheck
import GooglePlaces

Objective-C

@import FirebaseCore;      
@import FirebaseAppCheck;
@import GooglePlaces;

Krok 2. Dodaj bibliotekę App Check i inicjuj App Check

Firebase udostępnia instrukcje dotyczące każdego domyślnego dostawcy weryfikacji. Te instrukcje pokazują, jak skonfigurować projekt Firebase i dodać do aplikacji bibliotekę App Check. Aby zainicjować App Check, postępuj zgodnie z podanymi przykładami kodu.

Aby dodać bibliotekę App Check, postępuj zgodnie z instrukcjami Firebase:
- Instrukcje dotyczące weryfikacji aplikacji.
- Instrukcje dotyczące sprawdzania urządzenia

Inicjalizacja Sprawdzania aplikacji.

Jeśli używasz App Attest, postępuj zgodnie z dokumentacją Firebase dla deweloperów dotyczącą App Attest.

Aby utworzyć implementację AppCheckProviderFactory i dodać ją do pliku AppDelegate, postępuj zgodnie z instrukcjami Sprawdzania aplikacji Firebase.

Swift

let providerFactory = YourAppCheckProviderFactory()
AppCheck.setAppCheckProviderFactory(providerFactory)

Objective-C

YourAppCheckProviderFactory *providerFactory =
    [[YourAppCheckProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];

Jeśli używasz funkcji sprawdzania urządzenia, dodaj do AppDelegate te informacje:

Swift

AppCheck.setAppCheckProviderFactory(DeviceCheckProviderFactory())

Objective-C

[FIRAppCheck setAppCheckProviderFactory:providerFactory];

Krok 3. Dodaj dostawcę tokenów

Utwórz plik o nazwie AppCheckTokenProvider (lub, jeśli używasz języka Objective-C, 2 pliki o nazwach AppCheckTokenProvider.h i AppCheckTokenProvider.m) na poziomie głównym aplikacji. Dodaj te instrukcje importowania i definicję klasy:

Swift

// AppCheckTokenProvider.swift

import FirebaseAppCheck
import Foundation
import GooglePlaces

class AppCheckTokenProvider: NSObject, GMSPlacesAppCheckTokenProvider {
  func fetchAppCheckToken() async throws -> String {
    return try await AppCheck.appCheck().token(forcingRefresh: false).token
  }
}

Objective-C

// AppCheckTokenProvider.h

@import Foundation;
@import GooglePlaces;

@interface AppCheckTokenProvider : NSObject <GMSPlacesAppCheckTokenProvider>
@end

// AppCheckTokenProvider.m

#import "AppCheckTokenProvider.h"

@import FirebaseAppCheck;

@implementation AppCheckTokenProvider

- (void)fetchAppCheckTokenWithCompletion:(nonnull GMSAppCheckTokenCompletion)completion {
  [[FIRAppCheck appCheck]
      tokenForcingRefresh:NO
               completion:^(FIRAppCheckToken *_Nullable token, NSError *_Nullable error) {
                 if (token) {
                   completion(token.token, nil);
                 } else {
                   completion(nil, error);
                 }
               }];
}

@end

Krok 4. Inicjuj interfejsy API Places i App Check

W pliku AppDelegate zainicjuj interfejs Places API:

Swift

GMSPlacesClient.provideAPIKey("YOUR_API_KEY")

Objective-C

[GMSPlacesClient provideAPIKey:@"YOUR_API_KEY"];

Następnie zainicjuj interfejs App Check API:

Swift

GMSPlacesClient.setAppCheckTokenProvider(AppCheckTokenProvider())

Objective-C

[GMSPlacesClient setAppCheckTokenProvider:[[AppCheckTokenProvider alloc] init]];

Krok 5. Włącz debugowanie (opcjonalnie)

Jeśli chcesz opracowywać i testować aplikację lokalnie lub uruchamiać ją w środowisku ciągłej integracji (CI), możesz utworzyć wersję debugową aplikacji, która używa tajnego klucza debugowania do uzyskiwania prawidłowych tokenów App Check. Dzięki temu nie musisz używać w kompilacji debugowania rzeczywistych dostawców uwierzytelniania.

Aby przetestować aplikację w Symulatorze lub na urządzeniu testowym:

Tworzenie i konfigurowanie fabryki dostawców debugowania App Check.

Ten przykładowy kod obsługuje debugowanie i sytuacje produkcyjne:

Swift

#if targetEnvironment(simulator)
      let providerFactory = AppCheckDebugProviderFactory()
#else
      let providerFactory = YourAppCheckProviderFactory()
#endif

Objective-C

if (targetEnvironment == simulator){

FIRAppCheckDebugProviderFactory *providerFactory =
      [[FIRAppCheckDebugProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];
}

else {

YourAppCheckProviderFactory *providerFactory =
      [[YourAppCheckProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];
}

Włącz logowanie w projekcie Xcode, uruchom aplikację i znajdź w logach lokalny token debugowania.
Dodaj ten token do konsoli Firebase.
Więcej informacji i instrukcji znajdziesz w dokumentacji usługi App Check.

Aby uruchomić aplikację w środowisku CI:

Utwórz token debugowania w konsoli Firebase i dodaj go do bezpiecznego magazynu kluczy w systemie CI.
W Xcode dodaj do schematu testowania zmienną środowiskową o nazwie FIRAAppCheckDebugToken i wartości $(APP_CHECK_DEBUG_TOKEN) (lub podobnej).
W skrypcie testu CI prześlij token debugowania jako środowisko

Tworzenie i konfigurowanie fabryki dostawców debugowania App Check.

Ten przykładowy kod obsługuje debugowanie i sytuacje produkcyjne:

Swift

  #if targetEnvironment(ci)
        let providerFactory = AppCheckDebugProviderFactory()
        AppCheck.setAppCheckProviderFactory(providerFactory)
  #else
        let providerFactory = YourAppCheckProviderFactory()
  #endif

Objective-C

if (targetEnvironment == ci) {
FIRAppCheckDebugProviderFactory *providerFactory =
      [[FIRAppCheckDebugProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];
}

else {
YourAppCheckProviderFactory *providerFactory =
      [[YourAppCheckProviderFactory alloc] init];
[FIRAppCheck setAppCheckProviderFactory:providerFactory];
}

Więcej informacji i instrukcji znajdziesz w dokumentacji usługi App Check.

Krok 6. Monitoruj prośby o aplikację i podejmuj decyzje dotyczące egzekwowania zasad

Zanim zaczniesz egzekwować zasady, upewnij się, że nie zakłócisz działania aplikacji w przypadku jej legalnych użytkowników. W tym celu otwórz ekran danych z aplikacji, aby sprawdzić, jaki odsetek ruchu w aplikacji jest zweryfikowany, nieaktualny lub nielegalny. Gdy zauważysz, że większość ruchu jest zweryfikowana, możesz włączyć egzekwowanie.

Więcej informacji i instrukcji znajdziesz w dokumentacji Sprawdzania aplikacji Firebase.