Iniciadores Rápidos
¿Cómo construir un backend para Kotlin?

39min
Introducción
En este tutorial, aprenderás a construir un backend completo para una aplicación de Android (escrita en Kotlin) utilizando Back4App.
Recorreremos la integración de características esenciales de Back4App, incluyendo gestión de bases de datos, funciones de Cloud Code, APIs REST y GraphQL, autenticación de usuarios y consultas en tiempo real (Live Queries), para crear un backend seguro, escalable y robusto que se comunique sin problemas con tu aplicación de Android.
También verás cómo la configuración rápida y el entorno intuitivo de Back4App pueden reducir drásticamente el tiempo y el esfuerzo en comparación con la configuración manual de servidores y bases de datos.
A lo largo del camino, ganarás experiencia práctica con funcionalidades clave, incluyendo características avanzadas de seguridad, programación de tareas con Cloud Jobs y configuración de webhooks para integraciones externas.
Al final de este tutorial, estarás bien preparado para mejorar esta configuración básica en una aplicación lista para producción, o incorporar fácilmente lógica personalizada y APIs de terceros según sea necesario.
Requisitos previos
Para completar este tutorial, necesitarás:
Una cuenta de Back4app y un nuevo proyecto de Back4app
 Comenzando con Back4app.
Si no tienes una cuenta, puedes crear una gratis. Sigue la guía anterior para preparar tu proyecto.
Entorno básico de desarrollo de Android/Kotlin
 Asegúrate de tener Android Studio instalado en tu máquina. Puedes seguir la documentación oficial de configuración de Android Studio si aún no lo has configurado.
Un mínimo de Android 4.0 o superior en la configuración Gradle de tu aplicación
Típicamente, establecerás esto en tu minSdkVersion en el build.gradle de tu módulo.
Familiaridad con Kotlin y conceptos básicos de Android
 Documentación para desarrolladores de Android.
Si eres nuevo en Android o Kotlin, revisa la documentación oficial o un tutorial para principiantes antes de comenzar.
Asegúrate de tener todos estos requisitos previos en su lugar antes de comenzar. Tener tu proyecto de Back4app configurado y tu entorno local de Android listo te ayudará a seguir más fácilmente.
Paso 1 – Configuración del Proyecto de Back4app
Crear un Nuevo Proyecto
El primer paso para construir tu backend de Android en Back4app es crear un nuevo proyecto. Si aún no has creado uno, sigue estos pasos:
Inicia sesión en tu cuenta de Back4app.
Haz clic en el botón “Nueva App” en tu panel de control de Back4app.
Dale un nombre a tu app (por ejemplo, “Android-Kotlin-Backend-Tutorial”).
﻿
Una vez que se crea el proyecto, lo verás listado en tu panel de control de Back4app. Este proyecto será la base para todas las configuraciones de backend discutidas en este tutorial.
Conectar el SDK de Parse
Back4App se basa en la Plataforma Parse para gestionar tus datos, proporcionar características en tiempo real, manejar la autenticación de usuarios y más. Integrar tu aplicación de Android con Back4App implica agregar las dependencias del SDK de Parse para Android a tus archivos Gradle e inicializarlas con las credenciales de tu panel de control de Back4App.
Recupera tus Claves de Parse:
En tu panel de control de Back4App, navega a la sección “Configuración de la aplicación” o “Seguridad y Claves” de tu aplicación para encontrar tu ID de Aplicación y Clave de Cliente. También encontrarás la URL del Servidor Parse (a menudo en el formato https://parseapi.back4app.com).
﻿
Agrega el SDK de Parse a tus build.gradle archivos:
En tu build.gradle raíz (nivel de proyecto):
Text
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
﻿
En tu build.gradle a nivel de módulo (usualmente app/build.gradle):
Text
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
﻿
Inicializa Parse en tu aplicación de Android:
Crea una Application personalizada (por ejemplo, App.kt) si aún no tienes una:
Kotlin
package com.example.app

import android.app.Application
import com.parse.Parse
import com.parse.ParseInstallation

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
package com.example.app

import android.app.Application
import com.parse.Parse
import com.parse.ParseInstallation

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
﻿
A continuación, abre tu AndroidManifest.xml y registra la Application personalizada:
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
﻿
Al completar este paso, has establecido una conexión segura entre tu front end de Android (Kotlin) y el backend de Back4App. Todas las solicitudes y transacciones de datos se enrutan de manera segura a través de este SDK, reduciendo la complejidad de las llamadas manuales REST o GraphQL (aunque aún puedes usarlas cuando sea necesario).
Paso 2 – Configuración de la Base de Datos
Guardar y Consultar Datos
Con tu proyecto de Back4App configurado y el SDK de Parse integrado en tu aplicación de Android, ahora puedes comenzar a guardar y recuperar datos. A continuación se muestra un ejemplo utilizando Kotlin para crear y obtener datos.
Kotlin
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
﻿
Alternativamente, puedes usar los puntos finales de la API REST de Back4App:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Back4app también proporciona una interfaz GraphQL:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Estas diversas opciones te permiten integrar operaciones de datos de la manera que mejor se adapte a tu proceso de desarrollo, ya sea a través del SDK de Parse, REST o GraphQL.
Diseño de Esquema y Tipos de Datos
Por defecto, Parse permite la creación de esquemas sobre la marcha, pero también puedes definir tus clases y tipos de datos en el panel de control de Back4app para tener más control.
Navega a la sección “Base de datos” en tu panel de control de Back4app.
Crea una nueva clase (por ejemplo, “Todo”) y añade columnas relevantes, como título (String) y estáCompleto (Boolean).
Crear Nueva Clase
﻿
Back4app ofrece un Agente de IA que puede ayudarte a diseñar tu modelo de datos:
Abre el Agente de IA desde tu panel de control de la aplicación o en el menú.
Describe tu modelo de datos en un lenguaje simple (por ejemplo, “Por favor, crea una nueva aplicación ToDo en back4app con un esquema de clase completo.”).
Deja que el Agente de IA cree el Esquema por ti.
﻿
Usar el Agente de IA puede ahorrarte tiempo al configurar tu arquitectura de datos y asegurar la consistencia en toda tu aplicación.
Datos Relacionales
Si tienes datos relacionales—digamos, un Category objeto que apunta a múltiples Todo elementos—puedes usar Pointers o Relations en Parse. Por ejemplo, agregar un puntero a un Category:
Kotlin
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
﻿
Cuando consultas, también puedes incluir datos de punteros:
Kotlin
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
﻿
Esta include("category") llamada obtiene los detalles de la categoría junto a cada Todo, haciendo que tus datos relacionales sean accesibles sin problemas.
Consultas en Vivo
Para actualizaciones en tiempo real, Back4app proporciona Live Queries. Puedes suscribirte a cambios en una clase específica desde tu aplicación de Android:
Habilita Live Queries en tu panel de Back4App bajo la Configuración del Servidor de tu aplicación.
Inicializa una Suscripción de Consulta en Vivo en tu código:
Kotlin
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
﻿
Cada vez que se crea, actualiza o elimina un nuevo Todo, el cliente recibe una notificación en tiempo real, lo que es perfecto para aplicaciones colaborativas o dinámicas.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Mecanismo de Seguridad de Back4app
Back4app toma la seguridad en serio al proporcionar Listas de Control de Acceso (ACLs) y Permisos a Nivel de Clase (CLPs). Estas características te permiten restringir quién puede leer o escribir datos a nivel de objeto o de clase, asegurando que solo los usuarios autorizados puedan modificar tus datos.
﻿
Listas de Control de Acceso (ACLs)
Una ACL se aplica a objetos individuales para determinar qué usuarios, roles o el público pueden realizar operaciones de lectura/escritura. Por ejemplo:
Kotlin
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
﻿
Permisos a Nivel de Clase (CLPs)
Los CLPs rigen los permisos predeterminados de toda la clase, como si la clase es legible o escribible públicamente.
Ve a tu Panel de Control de Back4app, selecciona tu aplicación y abre la Base de Datos sección.
Selecciona una clase (por ejemplo, “Todo”).
Abre la pestaña de Permisos a Nivel de Clase.
Configura tus predeterminados, como “Requiere Autenticación” para leer o escribir, o “Sin Acceso” para el público.
﻿
Paso 4 – Escribiendo Funciones de Código en la Nube
El Código en la Nube te permite ejecutar código personalizado similar a Kotlin en el Servidor Parse (subido como .js archivos), sin necesidad de gestionar la infraestructura del servidor. Esto es ideal para lógica de negocio, validaciones, disparadores y llamadas a APIs externas.
Cómo Funciona
Normalmente colocas funciones de JavaScript, disparadores y cualquier módulo npm requerido en un main.js archivo. Este archivo se despliega en tu proyecto de Back4App y se ejecuta en el entorno de Parse Server.
Casos de Uso Típicos
Lógica de Negocios
Validaciones de Datos
Disparadores (como beforeSave, afterSave)
Aplicación de Seguridad
Integraciones con APIs de terceros
Despliega Tu Función
A continuación se muestra una función simple de Cloud Code:
main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Desplegando a través del Back4App CLI:
Bash
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
﻿
Luego configura y despliega:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Llamando a tu función
Desde tu código de Android (Kotlin) a través del SDK de Parse:
Kotlin
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
﻿
También puedes llamarlo a través de REST o GraphQL de manera similar.
Paso 5 – Configurando la Autenticación
Autenticación de Usuario en Back4App
Back4App aprovecha la Clase Parse User para la autenticación. Parse maneja el hashing seguro de contraseñas, tokens de sesión y más de forma predeterminada.
Configurando la Autenticación de Usuario
En Kotlin, puedes crear un nuevo usuario:
Kotlin
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
﻿
Iniciar sesión con un usuario existente:
Kotlin
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
﻿
Los inicios de sesión sociales como Google, Facebook y Apple también se pueden integrar. Consulta Documentación de Inicio de Sesión Social para más detalles.
Gestión de Sesiones
Parse administra automáticamente los tokens de sesión. Puedes acceder al usuario actual:
Kotlin
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
﻿
Y cerrar sesión:
Kotlin
ParseUser.logOut()
ParseUser.logOut()
﻿
Paso 6 – Manejo del Almacenamiento de Archivos
Subiendo y Recuperando Archivos
Parse incluye la ParseFile clase para manejar las subidas de archivos:
Kotlin
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
﻿
Seguridad de Archivos
Puedes controlar quién puede subir o descargar archivos ajustando ACLs y CLPs o utilizando configuraciones específicas de archivos en la configuración del servidor parse.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Habilitar la verificación de correo electrónico en la configuración de tu panel de Back4App.
Configura tu dirección de envío, plantillas de correo electrónico o dominio personalizado si lo deseas.
Usa ParseUser.requestPasswordResetInBackground(email, callback) para activar un flujo de restablecimiento de contraseña en tu aplicación.
Paso 8 – Programación de Tareas con Cloud Jobs
Cloud Jobs te permite automatizar tareas rutinarias como limpiar datos o enviar notificaciones periódicas.
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
﻿
Programa la tarea en tu panel de Back4App bajo Configuración del Servidor > Tareas en Segundo Plano.
Paso 9 – Integrando Webhooks
Webhooks permiten que tu aplicación Back4App envíe solicitudes HTTP a un servicio externo cada vez que ocurren ciertos eventos.
Agrega un Webhook en tu Panel de Control de Back4App bajo Más > Webhooks.
Configura los disparadores (por ejemplo, después de guardar un nuevo objeto).
Agrega un endpoint de URL (como un webhook de Slack o Stripe).
Agregando un Webhook
﻿
Paso 10 – Explorando el Panel de Administración de Back4App
La Aplicación de Administración de Back4App es una interfaz web amigable para usuarios no técnicos para gestionar datos.
Habilítalo bajo Panel de Control de la Aplicación > Más > Aplicación de Administración.
Crea tu primer usuario administrador.
Elige un subdominio para acceder al panel de administración.
Inicia sesión para ver, editar o eliminar registros de tu base de datos fácilmente.
Habilitar Aplicación de Administración
﻿
Conclusión
Al seguir este tutorial completo, has:
Creado un backend seguro para una aplicación Android en Back4App.
Configurado una base de datos con esquemas de clase, tipos de datos y relaciones.
Integrado consultas en tiempo real (Consultas en Vivo) para actualizaciones de datos inmediatas.
Aplicado medidas de seguridad utilizando ACLs y CLPs para proteger y gestionar el acceso a los datos.
Implementado Cloud Code funciones para ejecutar lógica de negocio personalizada en el lado del servidor.
Configurado la autenticación de usuarios con soporte para verificación de correo electrónico y restablecimiento de contraseñas.
Gestionado cargas de archivos y recuperación, con controles de seguridad de archivos opcionales.
Programado Cloud Jobs para tareas automatizadas en segundo plano.
Usado Webhooks para integrarse con servicios externos.
Explorado el Panel de Administración de Back4App para la gestión de datos.
Con un sólido front end de Android (Kotlin) y un robusto backend de Back4App, ahora estás bien equipado para desarrollar aplicaciones ricas en características, escalables y seguras. Continúa explorando funcionalidades más avanzadas, integra tu lógica de negocio y aprovecha el poder de Back4App para ahorrarte innumerables horas en la administración de servidores y bases de datos. ¡Feliz codificación!
Próximos Pasos
Construir una aplicación de Android lista para producción ampliando este backend para manejar modelos de datos más complejos, estrategias de caché y optimizaciones de rendimiento.
Integrar características avanzadas como flujos de autenticación especializados, control de acceso basado en roles o APIs externas (como pasarelas de pago).
Consulta la documentación oficial de Back4app para profundizar en seguridad avanzada, ajuste de rendimiento y análisis de registros.
Explora otros tutoriales sobre aplicaciones de chat en tiempo real, paneles de IoT o servicios basados en ubicación. Puedes combinar las técnicas aprendidas aquí con APIs de terceros para crear aplicaciones complejas del mundo real.
﻿
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Swift?
¿Cómo construir un backend para Android?