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

40min
Introducción
En este tutorial, descubrirás cómo construir un backend para watchOS aplicaciones usando Back4App. 
Ya sea que estés creando una extensión de WatchKit para tu aplicación de iPhone o diseñando una experiencia independiente de Apple Watch, Back4App simplifica tu trabajo al proporcionar herramientas esenciales. 
Integrarás características como una base de datos segura, funciones de Cloud Code, consultas en tiempo real (Live Queries) y autenticación de usuarios, todo sin gestionar tus propios servidores.
También verás cómo la rutina de inicio rápido de Back4App y su entorno fácil de usar te permiten concentrarte en la funcionalidad de tus aplicaciones de watchOS, en lugar de configurar servidores. 
A lo largo del camino, aprenderás a manejar tareas como programar trabajos, configurar webhooks y configurar notificaciones push. 
Al final, tendrás una base sólida para extender tus aplicaciones de reloj o aplicaciones de iOS para necesidades a nivel de producción, todo mientras ofreces sincronización de datos sin problemas (a través de una conexión a internet) entre la aplicación de WatchKit y tu backend.
Requisitos previos
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 watchOS/Xcode
 Debes tener Xcode instalado con el SDK de watchOS. Puedes ejecutar y construir tu extensión de WatchKit en un Apple Watch real o en un simulador.
SDK de Parse Swift
Usa Swift Package Manager para instalar y configurar el SDK para tus watchOS o aplicaciones combinadas de iOS.
Familiaridad con Swift, Xcode y el ecosistema de desarrollo de Apple
 Documentación para desarrolladores de Apple.
Si eres nuevo en las plataformas de Apple, dedica un tiempo a explorar la documentación de watchOS e iOS antes de comenzar.
Asegúrate de cumplir con estos requisitos previos antes de comenzar. Tener tu proyecto de Back4App configurado y tu entorno local de watchOS listo te ayudará a seguir sin problemas.
Paso 1 – Crear un nuevo proyecto en Back4App y conectar
Por qué necesitas un proyecto de Back4App
Un nuevo proyecto de Back4App es esencial para almacenar todos los datos y ejecutar código en la nube para tus aplicaciones de watchOS. Esto sirve como la base de tu backend.
Crea tu proyecto
Inicia sesión en Back4App.
Haz clic en “Nueva App” en el panel de control.
Nombra tu app (por ejemplo, “WatchOS-Backend-Tutorial”).
﻿
Instala Parse Swift SDK
Agrega la dependencia de Parse Swift en tu Package.swift o usando Archivo → Paquetes Swift → Agregar Dependencia de Paquete en Xcode. Proporciona la URL:
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")
]
﻿
Inicializa Parse en tu código de watchOS o compartido
En el código de inicio de tu aplicación WatchKit o en un archivo compartido accesible tanto por tu watchOS como por tu iPhone app, inicializa Parse:
Swift
@main
struct MyWatchApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APP_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
@main
struct MyWatchApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APP_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
En este punto, tu watchOS aplicación puede comunicarse con el backend de Back4App. Ya sea una Apple Watch aplicación independiente o una WatchKit extension emparejada con una iPhone app, todos los datos del backend fluyen a través del SDK de Parse Swift.
Paso 2 – Configuración de la Base de Datos
1. Creando un Modelo de Datos
Back4App utiliza la característica de esquema-en-escritura de Parse Server. Puedes definir tablas (clases) en la Back4App Database sección o dejar que se creen automáticamente cuando los objetos se guardan por primera vez. Por ejemplo, si tus watch apps rastrean datos de salud, podrías tener una clase “HealthMetrics” con campos como heartRate, steps, o workoutType.
2. Creando un Modelo de Datos usando el Agente de IA
El Agente de IA de Back4App te permite describir tu esquema en lenguaje sencillo:
Abre el Agente de IA en el panel de tu aplicación.
Proporciona detalles como “Por favor, configura una clase de Métricas de Observación con campos: dailySteps (Número), heartRate (Número).”
La IA creará el esquema automáticamente para ti.
﻿
3. Leyendo y Escribiendo Datos usando el SDK
A continuación se muestra un ejemplo de cómo guardar y consultar datos desde una aplicación watchOS. Supongamos que tenemos una HealthMetrics estructura:
Swift
import ParseSwift

struct HealthMetrics: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var dailySteps: Int?
    var heartRate: Int?
}

// Saving data
func saveMetrics(steps: Int, heart: Int) async {
    var metrics = HealthMetrics()
    metrics.dailySteps = steps
    metrics.heartRate = heart

    do {
        let saved = try await metrics.save()
        print("Saved metrics: \(saved)")
    } catch {
        print("Error saving: \(error)")
    }
}

// Querying data
func fetchLatestMetrics() async {
    let query = HealthMetrics.query()
    do {
        let results = try await query.find()
        print("Fetched: \(results.count) items")
    } catch {
        print("Error fetching: \(error)")
    }
}
import ParseSwift

struct HealthMetrics: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var dailySteps: Int?
    var heartRate: Int?
}

// Saving data
func saveMetrics(steps: Int, heart: Int) async {
    var metrics = HealthMetrics()
    metrics.dailySteps = steps
    metrics.heartRate = heart

    do {
        let saved = try await metrics.save()
        print("Saved metrics: \(saved)")
    } catch {
        print("Error saving: \(error)")
    }
}

// Querying data
func fetchLatestMetrics() async {
    let query = HealthMetrics.query()
    do {
        let results = try await query.find()
        print("Fetched: \(results.count) items")
    } catch {
        print("Error fetching: \(error)")
    }
}
﻿
4. Lectura y escritura de datos utilizando REST API
Si es necesario, tus watchOS o iOS apps también pueden enviar solicitudes REST:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dailySteps": 8000, "heartRate": 75}' \
  https://parseapi.back4app.com/classes/HealthMetrics
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dailySteps": 8000, "heartRate": 75}' \
  https://parseapi.back4app.com/classes/HealthMetrics
﻿
5. Lectura y escritura de datos utilizando GraphQL
Back4App también proporciona un endpoint de GraphQL. Por ejemplo:
GraphQL
mutation {
  createHealthMetrics(input: {
    fields: {
      dailySteps: 7500
      heartRate: 70
    }
  }) {
    healthMetrics {
      objectId
      dailySteps
      heartRate
    }
  }
}
mutation {
  createHealthMetrics(input: {
    fields: {
      dailySteps: 7500
      heartRate: 70
    }
  }) {
    healthMetrics {
      objectId
      dailySteps
      heartRate
    }
  }
}
﻿
6. Trabajando con consultas en vivo (opcional)
Si necesitas actualizaciones de datos en tiempo real en tu Apple Watch, habilita las consultas en vivo:
Activa Live Queries en Server Settings en Back4App.
Configura la URL de la consulta en vivo en tu código de watchOS:
Swift
ParseLiveQuery.configure(url: URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!)
ParseLiveQuery.configure(url: URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!)
﻿
Luego suscríbete a los cambios:
Swift
func subscribeMetricsUpdates() async throws {
    let subscription = HealthMetrics.query().subscribe()
    for try await event in subscription {
        switch event {
        case .created(let newData):
            print("New data: \(newData)")
        case .updated(let updatedData):
            print("Updated: \(updatedData)")
        default:
            break
        }
    }
}
func subscribeMetricsUpdates() async throws {
    let subscription = HealthMetrics.query().subscribe()
    for try await event in subscription {
        switch event {
        case .created(let newData):
            print("New data: \(newData)")
        case .updated(let updatedData):
            print("Updated: \(updatedData)")
        default:
            break
        }
    }
}
﻿
Paso 3 – Aplicando seguridad con ACLs y CLPs
1. Breve descripción
Back4App permite Listas de Control de Acceso (ACLs) y Permisos a Nivel de Clase (CLPs) para asegurar tu base de datos. Por ejemplo, puedes restringir ciertas métricas al usuario que las generó o permitir acceso de lectura solo a cuentas autenticadas.
2. Configuración paso a paso
Permisos a Nivel de Clase
Ve a Base de datos → Clase → Seguridad para definir los valores predeterminados (por ejemplo, solo lectura para todos, escritura para propietarios).
ACLs en Código
Puedes agregar ACLs a cada objeto en tu WatchKit o código compartido. Por ejemplo:
Swift
if let user = User.current {
    var acl = ParseACL()
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)

    var metrics = HealthMetrics()
    metrics.ACL = acl
}
if let user = User.current {
    var acl = ParseACL()
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)

    var metrics = HealthMetrics()
    metrics.ACL = acl
}
﻿
Esto asegura que solo el usuario que ha iniciado sesión pueda ver o modificar los objetos HealthMetrics que crean.
Paso 4 – Escribiendo Funciones de Cloud Code
1. Por qué Cloud Code
Cloud Code te ayuda a ejecutar operaciones complejas o confidenciales del lado del servidor, como validación de datos, llamadas a API externas o registro. Esta configuración es útil para minimizar la carga de trabajo del dispositivo watchOS y preservar la vida de la batería en el Apple Watch.
2. Función de Ejemplo
En tu main.js:
JS
Parse.Cloud.define('processMetrics', async (request) => {
  const { dailySteps, heartRate } = request.params;
  if (!dailySteps || !heartRate) {
    throw 'Missing parameters.';
  }
  // Example: Simple calculation
  return dailySteps * heartRate;
});
Parse.Cloud.define('processMetrics', async (request) => {
  const { dailySteps, heartRate } = request.params;
  if (!dailySteps || !heartRate) {
    throw 'Missing parameters.';
  }
  // Example: Simple calculation
  return dailySteps * heartRate;
});
﻿
3. Despliegue
Usa el Back4App CLI para desplegar:
Bash
b4a deploy
b4a deploy
﻿
Esto asegura que solo el usuario que ha iniciado sesión pueda ver o modificar los objetos HealthMetrics que crean.
4. Instalando Módulos NPM
Si necesitas bibliotecas externas en tu Cloud Code:
Agrega dependencias en package.json (dentro de tu carpeta de Cloud Code).
Usa require('your-lib') en main.js.
Paso 5 – Configurando la Autenticación
1. Habilitar la Autenticación de Usuarios
Por defecto, la clase Usuario está lista en Back4App. Asegúrate de que “Habilitar Permisos a Nivel de Clase” esté configurado correctamente para los objetos de usuario.
2. Ejemplos de Código
En Parse Swift, puedes registrar un usuario desde tu código de watchOS:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpNewUser(name: String, pass: String, mail: String) async {
    var newUser = User()
    newUser.username = name
    newUser.password = pass
    newUser.email = mail

    do {
        let signedUp = try await newUser.signUp()
        print("Sign Up successful: \(signedUp)")
    } catch {
        print("Error signing up: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpNewUser(name: String, pass: String, mail: String) async {
    var newUser = User()
    newUser.username = name
    newUser.password = pass
    newUser.email = mail

    do {
        let signedUp = try await newUser.signUp()
        print("Sign Up successful: \(signedUp)")
    } catch {
        print("Error signing up: \(error)")
    }
}
﻿
3. Inicio de Sesión Social
Si planeas integrar el inicio de sesión de Apple, Google o Facebook en tu aplicación de watchOS o iPhone, puedes hacerlo con las funciones relevantes de inicio de sesión social de Parse Swift. Consulta Documentación de Back4App para más detalles.
Paso 6 – Manejo del Almacenamiento de Archivos
1. Configurando el Almacenamiento de Archivos
Si tus aplicaciones de reloj necesitan subir imágenes, registros o pequeños archivos de datos, puedes confiar en ParseFile:
Swift
func uploadFile(data: Data, fileName: String) async {
    let file = ParseFile(name: fileName, data: data)
    do {
        let savedFile = try await file.save()
        print("Uploaded file: \(savedFile.url ?? "")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
func uploadFile(data: Data, fileName: String) async {
    let file = ParseFile(name: fileName, data: data)
    do {
        let savedFile = try await file.save()
        print("Uploaded file: \(savedFile.url ?? "")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
﻿
2. Ejemplo
Puedes almacenar imágenes de entrenamientos o instantáneas de progreso diario:
Swift
let snapshotData = // ...some image data from watch screenshot
Task {
    await uploadFile(data: snapshotData, fileName: "workout.jpg")
}
let snapshotData = // ...some image data from watch screenshot
Task {
    await uploadFile(data: snapshotData, fileName: "workout.jpg")
}
﻿
3. Consideraciones de Seguridad
Revisa tus ACLs de archivo. Por defecto, las URL de los archivos son accesibles si alguien obtiene el enlace directo. Puedes asegurar o controlar el acceso a los archivos a través de la configuración de archivos de tu servidor de parse.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
1. Descripción General
Los usuarios de Apple Watch pueden no gestionar siempre los inicios de sesión directamente en el reloj, pero habilitar la verificación de correo electrónico ayuda a mantener sus datos seguros.
2. Configuración del Panel de Control de Back4App
Ve a Configuraciones de la Aplicación → Correo Electrónico.
Activa Verificación de Correo Electrónico.
Personaliza las plantillas según sea necesario.
3. Código/Implementación
Para restablecimientos de contraseña:
Swift
do {
    try await User.requestPasswordReset(email: "[email protected]")
} catch {
    print("Error requesting password reset: \(error)")
}
do {
    try await User.requestPasswordReset(email: "example@domain.com")
} catch {
    print("Error requesting password reset: \(error)")
}
﻿
Paso 8 – Programación de Tareas con Cloud Jobs
1. Lo que hacen los Cloud Jobs
Los Cloud Jobs te permiten automatizar tareas en segundo plano como rotar datos antiguos o generar informes de uso para tus análisis de watchOS.
2. Ejemplo
En main.js:
JS
Parse.Cloud.job('cleanUpMetrics', async (request) => {
  const query = new Parse.Query('HealthMetrics');
  // For example, remove records older than 7 days
  const now = new Date();
  const cutoff = new Date(now - 7 * 24 * 60 * 60 * 1000);
  query.lessThan('createdAt', cutoff);

  const oldMetrics = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldMetrics, { useMasterKey: true });
  return `Deleted ${oldMetrics.length} old records.`;
});
Parse.Cloud.job('cleanUpMetrics', async (request) => {
  const query = new Parse.Query('HealthMetrics');
  // For example, remove records older than 7 days
  const now = new Date();
  const cutoff = new Date(now - 7 * 24 * 60 * 60 * 1000);
  query.lessThan('createdAt', cutoff);

  const oldMetrics = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldMetrics, { useMasterKey: true });
  return `Deleted ${oldMetrics.length} old records.`;
});
﻿
Despliega tu código.
Ve a Configuraciones de la App → Configuraciones del Servidor → Tareas en Segundo Plano y prográmalo diariamente.
Programación de un Cloud Job
﻿
Paso 9 – Integración de Webhooks
1. Definición
Los webhooks notifican a servicios externos cuando ocurren ciertos eventos en tu aplicación. Por ejemplo, podrías querer enviar un ping a un canal de Slack cada vez que se registre una nueva métrica.
2. Configuración
En el panel de control de Back4App, ve a Más → Webhooks.
Agrega un webhook con un endpoint (como una URL de Slack).
Elige el evento (por ejemplo, “Nuevo registro en HealthMetrics”).
Agregando un Webhook
﻿
3. Ejemplo
Cada vez que un usuario agrega una nueva entrada de dailySteps, se notifica a tu canal de Slack. También puedes definir lógica más compleja en Cloud Code para enviar cargas útiles personalizadas a tus servicios externos.
Paso 10 – Explorando el Panel de Administración de Back4App
1. Dónde Encontrarlo
El Panel de Administración es accesible a través de tu consola de Back4App bajo Más → Aplicación de Administración.
Actívalo y crea un usuario administrador para la gestión de datos basada en la web si necesitas una interfaz sencilla para partes interesadas no técnicas.
Habilitar Aplicación de Administración
﻿
2. Características
Ver y editar datos
Gestionar registros y trabajos en la nube
Rastrear análisis o notificaciones push
Esta es una forma fácil de colaborar en datos sin necesidad de acceso directo a la base de datos o al código.
Conclusión
A lo largo de esta guía, aprendiste cómo construir un backend para watchOS utilizando las potentes características de Back4App. Configuraste un esquema de base de datos seguro, escribiste código en la nube, manejaste consultas en tiempo real e implementaste autenticación de usuarios. Ahora tu aplicación WatchKit puede almacenar y sincronizar datos con un mínimo de complicaciones.
Próximos pasos
Perfecciona tus aplicaciones de reloj integrando funciones avanzadas en la nube para notificaciones personalizadas o transformaciones de datos.
Explora funcionalidades adicionales de aplicaciones iOS, como sincronización en segundo plano y estrategias de almacenamiento en caché para tu Apple Watch.
Lee la documentación oficial de Back4App para más información sobre seguridad avanzada, análisis y rendimiento.
Optimiza para la App Store para distribuir tu extensión de watchOS o aplicación de reloj independiente.
Al expandir tu backend, puedes ofrecer robustas aplicaciones watchOS que funcionan sin problemas incluso con una conexión a internet. ¡Sigue construyendo y disfruta del poder de Back4App para tus experiencias en Apple Watch!
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para jQuery?
¿Cómo construir un backend para tvOS?