Llama a funciones desde tu app

Los SDK cliente de Cloud Functions para Firebase te permiten llamar a funciones directamente desde una app de Firebase. Para hacerlo, escribe e implementa una función HTTPS que admita llamadas en Cloud Functions y, luego, agrega lógica de cliente para llamar a la función desde tu app.

Nota: Cloud Functions para Firebase (2ª gen.) es una versión preliminar pública. Por lo tanto, la funcionalidad puede cambiar de manera tal que deje de ser compatible con versiones anteriores. Las versiones preliminares no están sujetas a ningún ANS ni a ninguna política de baja, y puede que se ofrezca asistencia limitada o no se ofrezca asistencia para ellas.

Es importante tener en cuenta que las funciones HTTPS que admiten llamadas son similares, pero no idénticas, a las funciones HTTP. Además, ten en cuenta que la firma de devolución de llamada cambió entre las funciones de 1ª y 2ª gen.:

// Adds two numbers to each other.
exports.addnumbers = onCall((request) => {
  // Numbers passed from the client.
  const firstNumber = request.data.firstNumber;
  const secondNumber = request.data.secondNumber;

  // Checking that attributes are present and are numbers.
  if (!Number.isFinite(firstNumber) || !Number.isFinite(secondNumber)) {
    // Throwing an HttpsError so that the client gets the error details.
    throw new HttpsError("invalid-argument", "The function must be called " +
            "with two arguments \"firstNumber\" and \"secondNumber\" which " +
            "must both be numbers.");
  }

  // returning result.
  return {
    firstNumber: firstNumber,
    secondNumber: secondNumber,
    operator: "+",
    operationResult: firstNumber + secondNumber,
  };
});
index.js

Las funciones que admiten llamadas tienen estas diferencias clave respecto de las funciones HTTP:

• Con las funciones que admiten llamadas, los tokens de Firebase Authentication, de FCM y de Verificación de aplicaciones se incluyen en las solicitudes automáticamente cuando están disponibles.
• El activador functions.https.onCall deserializa automáticamente el cuerpo de la solicitud y valida los tokens de autenticación.

El SDK de Firebase para Cloud Functions (2nd gen) y las versiones posteriores funcionan en conjunto con estas versiones mínimas del SDK cliente de Firebase a fin de tener compatibilidad con las funciones HTTPS que admiten llamadas:

• SDK de Firebase para plataformas de Apple 10.9.0
• SDK de Firebase para Android 20.3.0
• SDK de Firebase web modular 9.7.0

Si quieres agregar una funcionalidad similar a una app creada en una plataforma no compatible, consulta la especificación del protocolo de https.onCall. En el resto de esta guía, se proporcionan instrucciones para escribir, implementar y llamar a una función HTTPS que admite llamadas en las plataformas de Apple, Android, la Web, C++ y Unity.

Escribe e implementa la función que admite llamadas

Usa el método onCall del subpaquete functions/v2/https para crear una función HTTP que admita llamadas. Este método acepta un parámetro event con propiedades data, auth, app y instanceToken:

// Saves a message to the Firebase Realtime Database but sanitizes the
// text by removing swearwords.
exports.addmessage = onCall((request) => {
  // ...
});
index.js

En el caso de una función que admite llamadas y guarda un mensaje de texto en Realtime Database, por ejemplo, data podría contener el texto del mensaje y la información de autenticación en auth:

// 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;
index.js

La distancia entre la ubicación de la función que admite llamadas y la ubicación del cliente que emite la llamada puede generar latencia de red. Para optimizar el rendimiento, especifica la ubicación de la función cuando corresponda. Además, asegúrate de alinear la ubicación de la función que admite llamadas con la ubicación establecida cuando inicialices el SDK en el cliente.

De manera opcional, puedes adjuntar una certificación de Verificación de aplicaciones para proteger tus recursos de backend contra los abusos, como el fraude de facturación o la suplantación de identidad (phishing). Consulta cómo habilitar la Verificación de aplicaciones para Cloud Functions.

Nota: Usa solo la API de backend functions.https para escribir funciones que admiten llamadas. La API del activador de HTTP es completamente independiente de las funciones que admiten llamadas y no es interoperable con ellas.

Cómo devolver los resultados

Para devolver los datos al cliente, muestra los datos que pueden tener codificación JSON. Por ejemplo, para mostrar el resultado de una operación de suma:

// returning result.
return {
  firstNumber: firstNumber,
  secondNumber: secondNumber,
  operator: "+",
  operationResult: firstNumber + secondNumber,
};
index.js

Para mostrar los datos después de una operación asíncrona, muestra una promesa. Los datos que muestra la promesa se devuelven al cliente. Por ejemplo, podrías mostrar el texto depurado que la función que admite llamadas escribió en Realtime Database:

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

Maneja errores

Para garantizar que el cliente obtenga información útil sobre los errores, muestra los errores de una función que acepte llamadas arrojando una instancia de functions.https.HttpsError (o mostrando una promesa rechazada con ese error). El error tiene un atributo code que puede ser uno de los valores que se muestran en functions.https.HttpsError. Los errores también tienen una cadena message, que está vacía en su configuración predeterminada. También pueden tener un campo details opcional con un valor arbitrario. Si se arroja un error distinto de HttpsError desde tus funciones, el cliente recibirá un error con el mensaje INTERNAL y el código internal.

Por ejemplo, una función podría arrojar errores de autenticación y validación de datos con mensajes de error que se muestran al cliente que emite la llamada:

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

Implementa la función que admite llamadas

Cuando guardas en index.js una función que admite llamadas que se completó, esta se implementa con todas las otras funciones al ejecutar firebase deploy. A fin de implementar solo la función que admite llamadas, usa el argumento --only para ejecutar implementaciones parciales, como se muestra a continuación:

firebase deploy --only functions:addMessage

Si ves errores de permisos cuando implementas funciones, asegúrate de que se asignen los roles de IAM adecuados al usuario que ejecuta los comandos de implementación.

Configura el entorno de desarrollo de tu cliente

Asegúrate de cumplir todos los requisitos y de agregar las dependencias y las bibliotecas cliente necesarias a tu app.

iOS+

Sigue las instrucciones para agregar Firebase a tu app para Apple.

Usa Swift Package Manager para instalar y administrar las dependencias de Firebase.

Consulta nuestra guía de instalación para descubrir las diferentes formas en que puedes agregar los SDK de Firebase a tu proyecto de Apple, como importar frameworks directamente y usar CocoaPods.

1. En Xcode, con tu proyecto de app abierto, navega a File > Add Packages.
2. Cuando se te solicite, agrega el repositorio del SDK de Firebase para plataformas de Apple:

  https://github.com/firebase/firebase-ios-sdk

Nota: Los proyectos nuevos deberían usar la versión predeterminada del SDK (la más reciente), pero puedes elegir una versión anterior si es necesario.
3. Elige la biblioteca de Cloud Functions.
4. Cuando termines, Xcode comenzará a resolver y descargar automáticamente tus dependencias en segundo plano.

Web version 9

1. Sigue las instrucciones para agregar Firebase a tu app web. Asegúrate de ejecutar el siguiente comando desde la terminal:

   npm install firebase@9.21.0 --save

2. Solicita manualmente Firebase Core y Cloud Functions de la siguiente manera:

    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);

Kotlin+KTX

1. Sigue las instrucciones a fin de agregar Firebase a tu app para Android.

2. Agrega la dependencia para la biblioteca de Android de Cloud Functions en el archivo de Gradle (generalmente <project>/<app-module>/build.gradle) del módulo (nivel de app). Te recomendamos usar la BoM de Firebase para Android a fin de controlar las versiones de las bibliotecas.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.0.0')
   
       // 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-ktx'
   }

   Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.

   (Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM

   Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

   Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que utilices la BoM para administrar las versiones de las bibliotecas a fin de garantizar que todas las versiones sean compatibles.

   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-ktx:20.3.0'
   }

Java

1. Sigue las instrucciones a fin de agregar Firebase a tu app para Android.

2. Agrega la dependencia para la biblioteca de Android de Cloud Functions en el archivo de Gradle (generalmente <project>/<app-module>/build.gradle) del módulo (nivel de app). Te recomendamos usar la BoM de Firebase para Android a fin de controlar las versiones de las bibliotecas.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation platform('com.google.firebase:firebase-bom:32.0.0')
   
       // 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'
   }

   Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.

   (Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM

   Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

   Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que utilices la BoM para administrar las versiones de las bibliotecas a fin de garantizar que todas las versiones sean compatibles.

   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:20.3.0'
   }

Inicializa el SDK cliente

Inicializa una instancia de Cloud Functions:

Swift

lazy var functions = Functions.functions()
CloudAddCell.swift

Objective-C

@property(strong, nonatomic) FIRFunctions *functions;
// ...
self.functions = [FIRFunctions functions];
CloudAddCell.m

Web version 9

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
MainActivity.kt

Java

private FirebaseFunctions mFunctions;
// ...
mFunctions = FirebaseFunctions.getInstance();
MainActivity.java

Nota: Para llamar a una función que se ejecuta en cualquier ubicación que no sea la predeterminada (us-central1), debes configurar el valor apropiado durante la inicialización. Por ejemplo, en Android debes inicializar con getInstance(FirebaseApp app, String region).

Llama a la función

Swift

let addMessageURL = URL(string: "https://addmessage-xyz1234-uc.a.run.app/addMessage")!

functions.httpsCallable(addMessageURL).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
  }
}

Web version 9

import { getFunctions, httpsCallableFromURL } from 'firebase/functions';

const functions = getFunctions();
const addMessage = httpsCallableFromURL(
  functions,
  // the URL of the function
  "https://addmessage-xyz1234-uc.a.run.app/addMessage"
);

addMessage({ text: messageText })
  .then((result) => {
    // Read result of the Cloud Function.
    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
            // The URL of the function
            .getHttpsCallableFromUrl(URL("https://addmessage-xyz1234-uc.a.run.app/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
            }
}

Maneja errores en el cliente

El cliente recibe un error si el servidor arrojó un error o si se rechazó la promesa que se genera como resultado. Si el error que muestra la función es del tipo function.https.HttpsError, el cliente recibe el code, el message y los details del error del servidor. En caso contrario, el error contiene el mensaje INTERNAL y el código INTERNAL. Obtén información para manejar errores en tu función que admite llamadas.

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]
  }
  // ...
}
CloudAddCell.swift

Web version 9

import { getFunctions, httpsCallableFromURL } from "firebase/functions";

const functions = getFunctions();
const addMessage = httpsCallableFromURL(
  functions,
  // the URL of the function
  "https://addmessage-xyz1234-uc.a.run.app/addMessage"
);

addMessage({ text: messageText })
  .then((result) => {
    // Read result of the Cloud Function.
    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
            }
        }
    }
MainActivity.kt

Recomendado: Evita los abusos con la Verificación de aplicaciones

Antes de lanzar tu app, debes habilitar la Verificación de aplicaciones para asegurarte de que solo tus apps puedan acceder a los extremos de las funciones que admiten llamadas.