Pakiety SDK klienta Cloud Functions dla Firebase umożliwiają wywoływanie funkcji bezpośrednio z aplikacji Firebase. Aby wywołać funkcję z aplikacji w ten sposób, napisz i wdróż funkcję wywoływaną przez HTTP w Cloud Functions, a potem dodaj logikę klienta, która będzie wywoływać tę funkcję z aplikacji.
Pamiętaj, że funkcje wywoływane przez HTTP są podobne, ale nie identyczne. Aby korzystać z funkcji wywoływanych przez HTTP, musisz użyć pakietu SDK klienta dla swojej platformy w połączeniu z interfejsem API backendu (lub zaimplementować protokół). Elementy wywołujące różnią się od tych funkcji HTTP:
- W przypadku elementów wywoływanych tokeny uwierzytelniania Firebase, tokeny FCM i tokeny Sprawdzania aplikacji (jeśli są dostępne) są automatycznie uwzględniane w żądaniach.
- Aktywator automatycznie zmienia treść żądania i weryfikuje tokeny uwierzytelniania.
Pakiet SDK Firebase dla Cloud Functions (2 generacji lub wyższej) współpracuje z tymi minimalnymi wersjami pakietu SDK Firebase, aby obsługiwać funkcje wywoływane przez HTTPS:
- Pakiet SDK Firebase dla platform Apple 10.29.0
- Pakiet SDK Firebase na Androida 21.0.0
- Modułowy pakiet SDK Firebase w wersji 9.7.0
Jeśli chcesz dodać podobne funkcje do aplikacji utworzonej na nieobsługiwanej platformie, zapoznaj się ze specyfikacją protokołu dla https.onCall
. W pozostałej części tego przewodnika znajdziesz instrukcje tworzenia, wdrażania i wywoływania funkcji HTTP dla platform Apple, Androida, aplikacji internetowych, C++ i Unity.
Tworzenie i wdrażanie funkcji wywoływanej
Użyj metody functions.https.onCall
, aby utworzyć wywoływaną funkcję HTTPS. Ta metoda wykorzystuje 2 parametry: data
i opcjonalnie context
:
// Saves a message to the Firebase Realtime Database but sanitizes the // text by removing swearwords. exports.addMessage = functions.https.onCall((data, context) => { // ... });
W przypadku funkcji możliwej do wywołania, która zapisuje SMS-a w bazie danych czasu rzeczywistego, na przykład data
może zawierać tekst wiadomości, a parametry context
przedstawiają informacje dotyczące uwierzytelniania użytkownika:
// Message text passed from the client.
const text = request.data.text;
// Authentication / user information is automatically added to the request.
const uid = request.auth.uid;
const name = request.auth.token.name || null;
const picture = request.auth.token.picture || null;
const email = request.auth.token.email || null;
Odległość między lokalizacją funkcji wywoływanej a lokalizacją wywołującego klienta może powodować opóźnienia w sieci. Aby zoptymalizować wydajność, rozważ określenie lokalizacji funkcji w odpowiednich przypadkach i dopasuj lokalizację wywołania do lokalizacji ustawionej podczas inicjowania pakietu SDK po stronie klienta.
Opcjonalnie możesz dołączyć atest Sprawdzania aplikacji, aby chronić zasoby backendu przed nadużyciami takimi jak oszustwa rozliczeniowe czy wyłudzanie informacji. Zapoznaj się z artykułem na temat włączania wymuszania Sprawdzania aplikacji w Cloud Functions.
Odbieram wynik
Aby wysłać dane z powrotem do klienta, zwróć dane, które można zakodować w formacie JSON. Aby na przykład zwrócić wynik operacji dodawania:
// returning result.
return {
firstNumber: firstNumber,
secondNumber: secondNumber,
operator: "+",
operationResult: firstNumber + secondNumber,
};
Aby zwrócić dane po operacji asynchronicznej, zwróć obietnicę. Dane zwrócone w efekcie obietnicy są wysyłane z powrotem do klienta. Możesz na przykład zwrócić oczyszczony tekst, który funkcja wywoływana zapisał w bazie danych czasu rzeczywistego:
// Saving the new message to the Realtime Database.
const sanitizedMessage = sanitizer.sanitizeText(text); // Sanitize message.
return getDatabase().ref("/messages").push({
text: sanitizedMessage,
author: {uid, name, picture, email},
}).then(() => {
logger.info("New Message written");
// Returning the sanitized message to the client.
return {text: sanitizedMessage};
})
Obsługa błędów
Aby zapewnić klientowi dostęp do przydatnych szczegółów błędu, zwróć błędy z możliwości wywołania przez wywołanie (lub zwrócenie odrzuconej obietnicy) instancji functions.https.HttpsError
.
Błąd ma atrybut code
, który może być jedną z wartości wymienionych w miejscu functions.https.HttpsError
.
Błędy te zawierają też ciąg znaków message
, który domyślnie jest pusty. Mogą też mieć opcjonalne pole details
z dowolną wartością. Jeśli z Twoich funkcji zostanie zgłoszony błąd inny niż HttpsError
, klient zamiast tego otrzyma komunikat o błędzie z komunikatem INTERNAL
i kodem internal
.
Na przykład funkcja może zgłaszać błędy weryfikacji danych i uwierzytelniania z komunikatami o błędach w celu zwrócenia do klienta wywołującego:
// Checking attribute.
if (!(typeof text === "string") || text.length === 0) {
// Throwing an HttpsError so that the client gets the error details.
throw new HttpsError("invalid-argument", "The function must be called " +
"with one arguments \"text\" containing the message text to add.");
}
// Checking that the user is authenticated.
if (!request.auth) {
// Throwing an HttpsError so that the client gets the error details.
throw new HttpsError("failed-precondition", "The function must be " +
"called while authenticated.");
}
Wdrażanie funkcji możliwej do wywołania
Gdy zapiszesz zakończoną funkcję wywoływaną w obiekcie index.js
, zostanie ona wdrożona wraz ze wszystkimi innymi funkcjami po uruchomieniu firebase deploy
.
Aby wdrożyć tylko element możliwy do wywołania, użyj argumentu --only
jak pokazano na ekranie do przeprowadzenia wdrożeń częściowych:
firebase deploy --only functions:addMessage
Jeśli podczas wdrażania funkcji wystąpią błędy uprawnień, sprawdź, czy do użytkownika wykonującego polecenia wdrożeniowe są przypisane odpowiednie role uprawnień.
Konfigurowanie środowiska programistycznego klienta
Sprawdź, czy spełniasz wymagania wstępne, a następnie dodaj do aplikacji wymagane zależności i biblioteki klienta.
iOS+
Wykonaj instrukcje dodawania Firebase do aplikacji Apple.
Użyj menedżera pakietów Swift, aby zainstalować zależności Firebase i nimi zarządzać.
- Po otwarciu projektu aplikacji przejdź w Xcode do File > Add Packages (Plik > Dodaj pakiety).
- Gdy pojawi się prośba, dodaj repozytorium SDK platform Apple Platform SDK Firebase:
- Wybierz bibliotekę Cloud Functions.
- Dodaj flagę
-ObjC
do sekcji Inne flagi łączące w ustawieniach kompilacji celu. - Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie zależności w tle.
https://github.com/firebase/firebase-ios-sdk.git
Web
- Wykonaj instrukcje dodawania Firebase do swojej aplikacji internetowej. Pamiętaj, aby uruchomić w terminalu to polecenie:
npm install firebase@10.12.3 --save
Ręczne wymaganie zarówno podstawowych funkcji Firebase, jak i Cloud Functions:
import { initializeApp } from 'firebase/app'; import { getFunctions } from 'firebase/functions'; const app = initializeApp({ projectId: '### CLOUD FUNCTIONS PROJECT ID ###', apiKey: '### FIREBASE API KEY ###', authDomain: '### FIREBASE AUTH DOMAIN ###', }); const functions = getFunctions(app);
Web
- Wykonaj te instrukcje, aby dodać Firebase do swojej aplikacji internetowej.
- Dodaj do aplikacji podstawowe biblioteki klienta Firebase i Cloud Functions:
<script src="https://www.gstatic.com/firebasejs/8.10.1/firebase.js"></script> <script src="https://www.gstatic.com/firebasejs/8.10.1/firebase-functions.js"></script>
Pakiet SDK Cloud Functions jest też dostępny jako pakiet npm.
- Uruchom w terminalu to polecenie:
npm install firebase@8.10.1 --save
- Możesz ręcznie wymagać zarówno podstawowych funkcji Firebase, jak i Cloud Functions:
const firebase = require("firebase"); // Required for side-effects require("firebase/functions");
Kotlin+KTX
Wykonaj te instrukcje, aby dodać Firebase do swojej aplikacji na Androida.
W pliku Gradle (na poziomie modułu) modułu (na poziomie aplikacji) (zwykle
<project>/<app-module>/build.gradle.kts
lub<project>/<app-module>/build.gradle
) dodaj zależność z biblioteką Cloud Functions na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie funkcji Firebase Android BoM.dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:33.1.2")) // Add the dependency for the Cloud Functions library // When using the BoM, you don't specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-functions") }
Dzięki użyciu BoM Firebase Android BoM Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.
(Alternatywnie) Dodawanie zależności bibliotek Firebase bez korzystania z BM
Jeśli nie chcesz używać Firebase BoM, musisz określić każdą wersję biblioteki Firebase w wierszu zależności.
Pamiętaj, że jeśli w swojej aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek. Dzięki temu będziesz mieć pewność, że wszystkie wersje są zgodne.
dependencies { // Add the dependency for the Cloud Functions library // When NOT using the BoM, you must specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-functions:21.0.0") }
Java
Wykonaj te instrukcje, aby dodać Firebase do swojej aplikacji na Androida.
W pliku Gradle (na poziomie modułu) modułu (na poziomie aplikacji) (zwykle
<project>/<app-module>/build.gradle.kts
lub<project>/<app-module>/build.gradle
) dodaj zależność z biblioteką Cloud Functions na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie funkcji Firebase Android BoM.dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:33.1.2")) // Add the dependency for the Cloud Functions library // When using the BoM, you don't specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-functions") }
Dzięki użyciu BoM Firebase Android BoM Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.
(Alternatywnie) Dodawanie zależności bibliotek Firebase bez korzystania z BM
Jeśli nie chcesz używać Firebase BoM, musisz określić każdą wersję biblioteki Firebase w wierszu zależności.
Pamiętaj, że jeśli w swojej aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek. Dzięki temu będziesz mieć pewność, że wszystkie wersje są zgodne.
dependencies { // Add the dependency for the Cloud Functions library // When NOT using the BoM, you must specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-functions:21.0.0") }
Dart
Wykonaj instrukcje dodawania Firebase do aplikacji Flutter.
Aby zainstalować wtyczkę, uruchom to polecenie z poziomu głównego projektu Flutter:
flutter pub add cloud_functions
Po zakończeniu ponownie skompiluj aplikację Flutter:
flutter run
Po zainstalowaniu możesz uzyskać dostęp do wtyczki
cloud_functions
, importując ją do kodu Dart:import 'package:cloud_functions/cloud_functions.dart';
C++
W języku C++ z Androidem:
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do projektu C++.
- Dodaj bibliotekę
firebase_functions
do plikuCMakeLists.txt
.
W języku C++ na platformach Apple:
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do projektu C++.
- Dodaj pod Cloud Functions do
Podfile
:pod 'Firebase/Functions'
- Zapisz plik i uruchom:
pod install
- Dodaj do projektu Xcode podstawowe platformy Firebase i platformy Cloud Functions z pakietu SDK Firebase C++.
firebase.framework
firebase_functions.framework
Unity
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do projektu Unity.
- Dodaj do projektu Unity
FirebaseFunctions.unitypackage
z pakietu SDK Firebase Unity.
Zainicjuj pakiet SDK klienta
Zainicjuj instancję Cloud Functions:
Swift
lazy var functions = Functions.functions()
Objective-C
@property(strong, nonatomic) FIRFunctions *functions;
// ...
self.functions = [FIRFunctions functions];
Web
firebase.initializeApp({
apiKey: '### FIREBASE API KEY ###',
authDomain: '### FIREBASE AUTH DOMAIN ###',
projectId: '### CLOUD FUNCTIONS PROJECT ID ###'
databaseURL: 'https://### YOUR DATABASE NAME ###.firebaseio.com',
});
// Initialize Cloud Functions through Firebase
var functions = firebase.functions();
Web
const app = initializeApp({
projectId: '### CLOUD FUNCTIONS PROJECT ID ###',
apiKey: '### FIREBASE API KEY ###',
authDomain: '### FIREBASE AUTH DOMAIN ###',
});
const functions = getFunctions(app);
Kotlin+KTX
private lateinit var functions: FirebaseFunctions // ... functions = Firebase.functions
Java
private FirebaseFunctions mFunctions; // ... mFunctions = FirebaseFunctions.getInstance();
Dart
final functions = FirebaseFunctions.instance;
C++
firebase::functions::Functions* functions;
// ...
functions = firebase::functions::Functions::GetInstance(app);
Unity
functions = Firebase.Functions.DefaultInstance;
Wywołaj funkcję
Swift
functions.httpsCallable("addMessage").call(["text": inputField.text]) { result, error in
if let error = error as NSError? {
if error.domain == FunctionsErrorDomain {
let code = FunctionsErrorCode(rawValue: error.code)
let message = error.localizedDescription
let details = error.userInfo[FunctionsErrorDetailsKey]
}
// ...
}
if let data = result?.data as? [String: Any], let text = data["text"] as? String {
self.resultField.text = text
}
}
Objective-C
[[_functions HTTPSCallableWithName:@"addMessage"] callWithObject:@{@"text": _inputField.text}
completion:^(FIRHTTPSCallableResult * _Nullable result, NSError * _Nullable error) {
if (error) {
if ([error.domain isEqual:@"com.firebase.functions"]) {
FIRFunctionsErrorCode code = error.code;
NSString *message = error.localizedDescription;
NSObject *details = error.userInfo[@"details"];
}
// ...
}
self->_resultField.text = result.data[@"text"];
}];
Web
var addMessage = firebase.functions().httpsCallable('addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
var sanitizedMessage = result.data.text;
});
Web
import { getFunctions, httpsCallable } from "firebase/functions";
const functions = getFunctions();
const addMessage = httpsCallable(functions, 'addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
/** @type {any} */
const data = result.data;
const sanitizedMessage = data.text;
});
Kotlin+KTX
private fun addMessage(text: String): Task<String> { // Create the arguments to the callable function. val data = hashMapOf( "text" to text, "push" to true, ) return functions .getHttpsCallable("addMessage") .call(data) .continueWith { task -> // This continuation runs on either success or failure, but if the task // has failed then result will throw an Exception which will be // propagated down. val result = task.result?.data as String result } }
Java
private Task<String> addMessage(String text) { // Create the arguments to the callable function. Map<String, Object> data = new HashMap<>(); data.put("text", text); data.put("push", true); return mFunctions .getHttpsCallable("addMessage") .call(data) .continueWith(new Continuation<HttpsCallableResult, String>() { @Override public String then(@NonNull Task<HttpsCallableResult> task) throws Exception { // This continuation runs on either success or failure, but if the task // has failed then getResult() will throw an Exception which will be // propagated down. String result = (String) task.getResult().getData(); return result; } }); }
Dart
final result = await FirebaseFunctions.instance.httpsCallable('addMessage').call(
{
"text": text,
"push": true,
},
);
_response = result.data as String;
C++
firebase::Future<firebase::functions::HttpsCallableResult> AddMessage(
const std::string& text) {
// Create the arguments to the callable function.
firebase::Variant data = firebase::Variant::EmptyMap();
data.map()["text"] = firebase::Variant(text);
data.map()["push"] = true;
// Call the function and add a callback for the result.
firebase::functions::HttpsCallableReference doSomething =
functions->GetHttpsCallable("addMessage");
return doSomething.Call(data);
}
Unity
private Task<string> addMessage(string text) {
// Create the arguments to the callable function.
var data = new Dictionary<string, object>();
data["text"] = text;
data["push"] = true;
// Call the function and extract the operation from the result.
var function = functions.GetHttpsCallable("addMessage");
return function.CallAsync(data).ContinueWith((task) => {
return (string) task.Result.Data;
});
}
Obsługa błędów po stronie klienta
Klient otrzymuje błąd, jeśli serwer zwrócił błąd lub jeśli wynikowa obietnica została odrzucona.
Jeśli błąd zwrócony przez funkcję jest typu function.https.HttpsError
, klient otrzyma błąd code
, message
i details
z błędu serwera. W przeciwnym razie komunikat o błędzie zawiera komunikat INTERNAL
i kod INTERNAL
. Zapoznaj się ze wskazówkami dotyczącymi obsługi błędów w funkcji wywoływanej.
Swift
if let error = error as NSError? {
if error.domain == FunctionsErrorDomain {
let code = FunctionsErrorCode(rawValue: error.code)
let message = error.localizedDescription
let details = error.userInfo[FunctionsErrorDetailsKey]
}
// ...
}
Objective-C
if (error) {
if ([error.domain isEqual:@"com.firebase.functions"]) {
FIRFunctionsErrorCode code = error.code;
NSString *message = error.localizedDescription;
NSObject *details = error.userInfo[@"details"];
}
// ...
}
Web
var addMessage = firebase.functions().httpsCallable('addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
var sanitizedMessage = result.data.text;
})
.catch((error) => {
// Getting the Error details.
var code = error.code;
var message = error.message;
var details = error.details;
// ...
});
Web
import { getFunctions, httpsCallable } from "firebase/functions";
const functions = getFunctions();
const addMessage = httpsCallable(functions, 'addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
/** @type {any} */
const data = result.data;
const sanitizedMessage = data.text;
})
.catch((error) => {
// Getting the Error details.
const code = error.code;
const message = error.message;
const details = error.details;
// ...
});
Kotlin+KTX
addMessage(inputMessage) .addOnCompleteListener { task -> if (!task.isSuccessful) { val e = task.exception if (e is FirebaseFunctionsException) { val code = e.code val details = e.details } } }
Java
addMessage(inputMessage) .addOnCompleteListener(new OnCompleteListener<String>() { @Override public void onComplete(@NonNull Task<String> task) { if (!task.isSuccessful()) { Exception e = task.getException(); if (e instanceof FirebaseFunctionsException) { FirebaseFunctionsException ffe = (FirebaseFunctionsException) e; FirebaseFunctionsException.Code code = ffe.getCode(); Object details = ffe.getDetails(); } } } });
Dart
try {
final result =
await FirebaseFunctions.instance.httpsCallable('addMessage').call();
} on FirebaseFunctionsException catch (error) {
print(error.code);
print(error.details);
print(error.message);
}
C++
void OnAddMessageCallback(
const firebase::Future<firebase::functions::HttpsCallableResult>& future) {
if (future.error() != firebase::functions::kErrorNone) {
// Function error code, will be kErrorInternal if the failure was not
// handled properly in the function call.
auto code = static_cast<firebase::functions::Error>(future.error());
// Display the error in the UI.
DisplayError(code, future.error_message());
return;
}
const firebase::functions::HttpsCallableResult* result = future.result();
firebase::Variant data = result->data();
// This will assert if the result returned from the function wasn't a string.
std::string message = data.string_value();
// Display the result in the UI.
DisplayResult(message);
}
// ...
// ...
auto future = AddMessage(message);
future.OnCompletion(OnAddMessageCallback);
// ...
Unity
addMessage(text).ContinueWith((task) => {
if (task.IsFaulted) {
foreach (var inner in task.Exception.InnerExceptions) {
if (inner is FunctionsException) {
var e = (FunctionsException) inner;
// Function error code, will be INTERNAL if the failure
// was not handled properly in the function call.
var code = e.ErrorCode;
var message = e.ErrorMessage;
}
}
} else {
string result = task.Result;
}
});
Zalecane: zapobieganie nadużyciom dzięki Sprawdzaniu aplikacji
Przed opublikowaniem aplikacji włącz Sprawdzanie aplikacji, aby mieć pewność, że tylko Twoje aplikacje mają dostęp do punktów końcowych funkcji, które można wywołać.