Quickstarters
¿Cómo construir un backend para MacOS?

46min
Introducción
En este tutorial, aprenderás cómo construir un backend para MacOS utilizando Back4app y el SDK de Parse Swift. 
Recorreremos la integración de características esenciales de Back4app, como la gestión de bases de datos, funciones de Cloud Code, APIs REST y GraphQL, autenticación de usuarios y consultas en tiempo real (Consultas en Vivo), para crear un backend seguro, escalable y robusto que se comunique sin problemas con tu aplicación de MacOS.
También verás cómo la configuración rápida de Back4app y su entorno intuitivo 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, obtendrás experiencia práctica con funcionalidades clave, incluyendo características de seguridad avanzadas, 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 de macOS lista para producción, o incorporar fácilmente lógica personalizada y APIs de terceros según sea necesario.
Dominar este enfoque te empoderará para optimizar tus flujos de trabajo y aprender cómo construir un backend para MacOS de manera rápida y eficiente.
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.
Un entorno de desarrollo de MacOS (Xcode)
Puedes instalar Xcode desde el Mac App Store.
Swift Package Manager o CocoaPods
Para instalar el SDK de Parse Swift. Documentación de Parse Swift.﻿
Conocimientos básicos de Swift y desarrollo de aplicaciones macOS
Documentación oficial de Apple
La familiaridad con SwiftUI o AppKit es útil.
Asegúrate de tener todos estos requisitos previos en su lugar antes de comenzar. Tener tu proyecto de Back4app configurado y tu entorno de desarrollo local de macOS listo te ayudará a seguir más fácilmente.
Paso 1 – Configuración del Proyecto Back4app
Crear un Nuevo Proyecto
El primer paso para construir tu backend de macOS 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 Aplicación” en tu panel de control de Back4app.
Dale un nombre a tu aplicación (por ejemplo, “macOS-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 Swift
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. Conectar tu aplicación de macOS a Back4app implica instalar el SDK de Parse Swift e inicializarlo 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 (o clientKey). También encontrarás la URL del Servidor Parse (a menudo en el formato https://parseapi.back4app.com).
﻿
Instala el SDK de Parse Swift en tu proyecto de macOS:
Si usas Swift Package Manager:
Swift
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
﻿
Si usas CocoaPods, añade esto a tu Podfile:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Inicializa Parse en tu aplicación de macOS (por ejemplo, en AppDelegate.swift si usas AppKit, o en una @main struct si construyes una aplicación SwiftUI):
Swift
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
Al completar este paso, has establecido una conexión segura entre tu front-end de macOS (UI) 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 REST o GraphQL manuales (aunque aún puedes usarlas si es necesario).
Paso 2 – Configuración de la Base de Datos
Guardando y Consultando Datos
Con tu proyecto de Back4app configurado y el SDK de Parse Swift integrado en tu aplicación macOS, ahora puedes comenzar a guardar y recuperar datos. La forma más sencilla de crear un objeto es definir una estructura que conforme a ParseObject y luego llamar a save():
Swift
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
﻿
Alternativamente, puedes usar la API REST o GraphQL de Back4app:
Curl
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 Swift, 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áCompletado (Boolean).
Crear Nueva Clase
﻿
Back4app soporta varios tipos de datos: String, Número, Booleano, Objeto, Fecha, Archivo, Puntero, Array, Relación, GeoPoint, y Polígono. Puedes elegir el tipo apropiado para cada campo, o dejar que Parse cree automáticamente estas columnas cuando guardes un objeto desde tu aplicación de macOS por primera vez.
Crear Columna
﻿
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 App 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.
﻿
Datos Relacionales
Si tienes datos relacionales—digamos, un Category objeto que apunta a múltiples Todo elementos—puedes usar Pointers o Relations en Parse Swift:
Swift
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
﻿
Consultas en Vivo
Para actualizaciones en tiempo real, Back4app proporciona Live Queries. Al habilitar Live Queries en tu panel de Back4app, puedes suscribirte a cambios en una clase específica desde tu aplicación macOS.
Habilitar Live Queries en tu panel de Back4app bajo la Configuración del Servidor de tu aplicación.
Inicializar Live Queries en el código (el cliente de Live Query de Swift aún está en desarrollo, pero puedes usar enfoques impulsados por la comunidad o estar atento a las actualizaciones oficiales de Parse Swift).
src/parseConfig.swift
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
﻿
Una vez suscrito, recibirías notificaciones cada vez que se crea, actualiza o elimina un nuevo Todo. Esto es especialmente valioso para aplicaciones de escritorio colaborativas o altamente interactivas donde múltiples usuarios o procesos necesitan ver los últimos datos al instante.
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, si tu aplicación de macOS tiene un concepto de “tareas privadas” para el usuario actualmente conectado:
Swift
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
﻿
Cuando guardas el objeto, tiene un ACL que impide que cualquier persona que no sea el usuario especificado lo lea o modifique.
Editar ACL
﻿
Permisos a Nivel de Clase (CLPs)
Los CLPs rigen los permisos predeterminados de toda una clase, como si la clase es públicamente legible o escribible, o si solo ciertos roles pueden acceder a ella.
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 los permisos a nivel de clase.
Configura tus valores predeterminados, como “Requiere autenticación” para leer o escribir, o “Sin acceso” para el público.
﻿
Paso 4 – Escribir y desplegar funciones en la nube
El código en la nube es una característica del entorno de Parse Server que te permite ejecutar código JavaScript personalizado en el lado del servidor, sin necesidad de gestionar tus propios servidores o infraestructura. Al escribir código en la nube, puedes extender tu backend de Back4app con lógica empresarial adicional, validaciones, disparadores e integraciones que se ejecutan de manera segura y eficiente en el servidor Parse.
Cómo funciona
Cuando escribes código en la nube, normalmente colocas tus funciones de JavaScript, disparadores y cualquier módulo NPM requerido en un main.js archivo. Luego despliegas este archivo en tu proyecto de Back4app, y se ejecuta en el entorno de Parse Server. Esto te permite mantener la lógica sensible en el lado del servidor.
Casos de uso típicos:
Lógica empresarial: Cálculos o transformaciones antes de guardar datos
Validaciones de datos: Asegurar que ciertos campos cumplan con los criterios
Disparadores: Realizar acciones cuando los datos cambian
Integraciones: Conectar con APIs externas (por ejemplo, pagos, notificaciones)
Función de ejemplo
JS
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js
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 de la CLI de Back4app
Instalar la CLI:
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
Configura tu clave de cuenta:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Despliega tu código en la nube:
Bash
b4a deploy
b4a deploy
﻿
Llamando a tu función
Desde macOS usando Swift:
Swift
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
﻿
También puedes llamarlo a través de REST o GraphQL, de la misma manera que en otros frameworks.
Paso 5 – Configuración de la Autenticación de Usuario
Autenticación de Usuario en Back4app
Back4app aprovecha la ParseUser clase como base para la autenticación. Por defecto, Parse maneja el hash de contraseñas, los tokens de sesión y el almacenamiento seguro, por lo que no tienes que configurar flujos de seguridad complejos manualmente.
Configurando la Autenticación de Usuario
En una aplicación de macOS, puedes crear un nuevo usuario con:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
﻿
A través de REST, un inicio de sesión podría verse así:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Gestión de Sesiones
Después de un inicio de sesión exitoso, Parse crea un token de sesión. Puedes acceder al usuario actualmente conectado:
Swift
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
﻿
Cerrar sesión:
Swift
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
﻿
Integración de Inicio de Sesión Social
Puedes integrar proveedores populares como Google, Apple o Facebook configurando authData. Las instrucciones detalladas varían, así que consulta Documentación de Inicio de Sesión Social.﻿
Verificación de Correo Electrónico y Restablecimiento de Contraseña
Para habilitar la verificación de correo electrónico y el restablecimiento de contraseña:
Navega a la Configuración de Correo Electrónico en tu panel de Back4app.
Habilita la verificación de correo electrónico.
Configura la dirección del remitente, las plantillas de correo electrónico y tu dominio personalizado si lo deseas.
Esto mejora la seguridad de la cuenta al validar los correos electrónicos de los usuarios y proporcionar un método de recuperación de contraseña.
Paso 6 – Manejo del Almacenamiento de Archivos
Subiendo y Recuperando Archivos
Parse incluye la ParseFile clase para manejar las subidas de archivos, que Back4app almacena de forma segura:
Swift
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
﻿
Adjúntalo a un objeto:
Swift
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
﻿
Seguridad de Archivos
Puedes configurar la seguridad de carga de archivos en la configuración de tu servidor Parse. Por ejemplo, controlando qué usuarios pueden subir o eliminar archivos. Ten en cuenta que si compartes la URL del archivo, cualquier persona con esa URL puede acceder a él a menos que hayas establecido reglas más estrictas del lado del servidor.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Descripción General
La verificación de correo electrónico y los restablecimientos de contraseña son críticos para la gestión segura de usuarios. Ya hemos tocado este tema en Paso 5, pero como recordatorio:
Habilita estas funciones en el Panel de Control de Back4app (Configuración de Correo Electrónico).
Configura las plantillas de correo electrónico de “Habilitar Verificación de Correo Electrónico” y “Restablecimiento de Contraseña”.
Prueba el flujo desde tu aplicación de macOS.
Paso 8 – Programación de Tareas con Cloud Jobs
Cloud Jobs
Cloud Jobs te permite programar y ejecutar tareas rutinarias en tu backend, como enviar correos electrónicos periódicos o limpiar datos. Por ejemplo:
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Despliega tu Cloud Code con el nuevo trabajo.
Ve al Dashboard de Back4app > Configuraciones de la App > Configuraciones del Servidor > Trabajos en Segundo Plano.
Programa el trabajo (por ejemplo, diario).
Programando un Trabajo en la Nube
﻿
Paso 9 – Integrando Webhooks
Webhooks permiten que tu app de Back4app envíe solicitudes HTTP a un servicio externo cada vez que ocurren ciertos eventos. Esto es poderoso para integrarse con sistemas de terceros como pasarelas de pago, herramientas de marketing por correo electrónico o plataformas de análisis.
Navega a la configuración de Webhooks en tu dashboard de Back4app > Más > WebHooks.
Configura un endpoint (por ejemplo, https://your-external-service.com/webhook-endpoint).
Configura disparadores para especificar qué eventos en tus clases de Back4app o funciones de Cloud Code activarán el webhook.
Agregando un Webhook
﻿
Por ejemplo, si deseas notificar a Slack cada vez que se crea un nuevo Todo:
Crea una App de Slack que acepte webhooks entrantes.
Copia la URL del webhook de Slack.
En tu dashboard de Back4app, establece el endpoint a esa URL de Slack para el evento “Nuevo registro en la clase Todo.”
Paso 10 – Explorando el Panel de Administración de Back4app
El Back4app Admin App es una interfaz de gestión basada en la web diseñada para usuarios no técnicos para realizar operaciones CRUD y manejar tareas de datos rutinarias sin escribir ningún código. Proporciona una centrada en el modelo, amigable para el usuario interfaz que simplifica la administración de bases de datos, la gestión de datos personalizados y las operaciones a nivel empresarial.
Habilitando la Aplicación de Administración
Habilitar yendo a App Dashboard > Más > Admin App y haciendo clic en “Habilitar Aplicación de Administración.”
Habilitar Aplicación de Administración
﻿
Crear un Primer Usuario Administrador, que genera automáticamente un nuevo rol (B4aAdminUser) y clases relevantes en el esquema de tu aplicación.
﻿
Elegir un Subdominio para acceder a la interfaz de administración y completar la configuración.
﻿
Iniciar Sesión utilizando las credenciales de administrador que creaste para acceder a tu nuevo panel de control de la Aplicación de Administración.
﻿
Una vez habilitada, la aplicación de administración de Back4app facilita la visualización, edición o eliminación de registros de su base de datos, sin requerir el uso directo del Panel de Control de Parse o código de backend.
Conclusión
Al seguir este tutorial completo, usted ha:
Creado un backend seguro para una aplicación de macOS 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 funciones de Cloud Code 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 trabajos en la nube 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 macOS y un robusto backend de Back4app, ahora estás bien equipado para desarrollar aplicaciones de escritorio ricas en funciones, 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.
Próximos Pasos
Construir una aplicación de macOS 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 comunicación en tiempo real, paneles de IoT o servicios basados en ubicación. Combina 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 tvOS?
¿Cómo construir un backend para iOS?