Quickstarters
¿Cómo construir un backend para Blazor?

39min
Introducción
En este tutorial, aprenderás a construir un backend completo para una aplicación Blazor utilizando Back4app.
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 (Live Queries) - para crear un backend seguro, escalable y robusto que se comunique sin problemas con tu frontend de Blazor.
Aprovechar los robustos servicios de backend de Back4app con Blazor, un marco de trabajo ASP.NET Core para construir interfaces web interactivas utilizando C#, permite a los desarrolladores acelerar el desarrollo del backend.
Ya sea que estés construyendo una aplicación Blazor Server o una aplicación Blazor WebAssembly, la integración sin problemas con Back4app puede reducir drásticamente el tiempo de desarrollo mientras asegura una lógica de negocio de alta calidad en el lado del servidor.
Al final de este tutorial, habrás construido una estructura de backend segura adaptada para una aplicación web de pila completa utilizando Blazor.
Obtendrás información sobre cómo manejar operaciones de datos, aplicar controles de seguridad e implementar funciones en la nube, haciendo que tu aplicación web Blazor sea robusta y escalable.
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 Blazor
Puedes configurarlo instalando el SDK de .NET más reciente desde Microsoft y creando un nuevo proyecto de Blazor utilizando plantillas como dotnet new blazorserver o dotnet new blazorwasm.
.NET SDK (versión 6 o superior) instalado
Asegúrate de tener el SDK de .NET para construir y ejecutar aplicaciones Blazor.
Familiaridad con C# y conceptos de Blazor
Documentación oficial de Blazor.
Si eres nuevo en Blazor, revisa la documentación oficial o un tutorial para principiantes antes de comenzar.
Asegúrate de tener estos requisitos previos antes de comenzar para garantizar una experiencia de tutorial fluida.
Paso 1 – Configuración del Proyecto Back4app
Crear un Nuevo Proyecto
El primer paso para construir tu backend de Blazor 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, “Blazor-Backend-Tutorial”).
﻿
Esta configuración asegura que cada vez que uses Parse en tu aplicación Blazor, esté preconfigurada para conectarse a tu instancia específica de Back4app.
Al completar este paso, has establecido una conexión segura entre tu frontend de Blazor y el backend de Back4app, allanando el camino para realizar operaciones de base de datos, gestión de usuarios y más.
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 Blazor, ahora puedes comenzar a guardar y recuperar datos. La forma más sencilla de crear un registro es usar el ParseObject clase:
SomeDataService.cs
using Parse;
using System.Threading.Tasks;

public class SomeDataService {
    public async Task<ParseObject> CreateTodoItemAsync(string title, bool isCompleted) {
        var todo = new ParseObject("Todo");
        todo["title"] = title;
        todo["isCompleted"] = isCompleted;

        try {
            await todo.SaveAsync();
            Console.WriteLine("Todo saved successfully: " + todo.ObjectId);
            return todo;
        } catch (Exception ex) {
            Console.WriteLine("Error saving Todo: " + ex.Message);
            return null;
        }
    }

    public async Task<IList<ParseObject>> FetchTodosAsync() {
        var query = new ParseQuery<ParseObject>("Todo");
        try {
            var results = await query.FindAsync();
            Console.WriteLine("Fetched Todo items: " + results.Count);
            return results;
        } catch (Exception ex) {
            Console.WriteLine("Error fetching Todos: " + ex.Message);
            return null;
        }
    }
}
using Parse;
using System.Threading.Tasks;

public class SomeDataService {
    public async Task<ParseObject> CreateTodoItemAsync(string title, bool isCompleted) {
        var todo = new ParseObject("Todo");
        todo["title"] = title;
        todo["isCompleted"] = isCompleted;

        try {
            await todo.SaveAsync();
            Console.WriteLine("Todo saved successfully: " + todo.ObjectId);
            return todo;
        } catch (Exception ex) {
            Console.WriteLine("Error saving Todo: " + ex.Message);
            return null;
        }
    }

    public async Task<IList<ParseObject>> FetchTodosAsync() {
        var query = new ParseQuery<ParseObject>("Todo");
        try {
            var results = await query.FindAsync();
            Console.WriteLine("Fetched Todo items: " + results.Count);
            return results;
        } catch (Exception ex) {
            Console.WriteLine("Error fetching Todos: " + ex.Message);
            return null;
        }
    }
}
﻿
Alternativamente, puedes usar los endpoints de la API REST de Back4app para operaciones.
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 agrega columnas relevantes, como título (String) y estáCompletado (Boolean).
Crear nueva clase
﻿
Al consultar, incluye datos de puntero:
SomeDataService.cs (continuation)
public async Task<IList<ParseObject>> FetchTodosWithCategoryAsync() {
    var query = new ParseQuery<ParseObject>("Todo").Include("category");
    try {
        var todosWithCategory = await query.FindAsync();
        return todosWithCategory;
    } catch (Exception ex) {
        Console.WriteLine("Error fetching todos with category: " + ex.Message);
        return null;
    }
}
public async Task<IList<ParseObject>> FetchTodosWithCategoryAsync() {
    var query = new ParseQuery<ParseObject>("Todo").Include("category");
    try {
        var todosWithCategory = await query.FindAsync();
        return todosWithCategory;
    } catch (Exception ex) {
        Console.WriteLine("Error fetching todos with category: " + ex.Message);
        return null;
    }
}
﻿
Consultas en Vivo
Para actualizaciones en tiempo real en una aplicación Blazor Server, considera usar conexión SignalR para Consultas en Vivo. Aunque el SDK de Parse .NET soporta Consultas en Vivo, integrarlas directamente dentro de una aplicación Blazor puede requerir una configuración adicional con SignalR para la comunicación en tiempo real.
Habilitar Consultas en Vivo en tu panel de Back4app bajo la Configuración del Servidor. Asegúrate de que “Consultas en Vivo” esté activado.
Configurar Cliente de Consulta en Vivo en .NET si es necesario. Sin embargo, para aplicaciones Blazor, aprovechar SignalR podría ser más idiomático para conexiones del lado del servidor.
Debido a la complejidad de configurar Consultas en Vivo dentro de Blazor y las posibles limitaciones del SDK de Parse .NET en Blazor WebAssembly, es posible que necesites implementar un servicio del lado del servidor que conecte las Consultas en Vivo de Parse con los clientes de SignalR.
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:
SomeDataService.cs (ACL example)
public async Task<ParseObject> CreatePrivateTodoAsync(string title, ParseUser ownerUser) {
    var todo = new ParseObject("Todo");
    todo["title"] = title;

    // Create an ACL granting read/write access only to the owner
    var acl = new ParseACL(ownerUser);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    todo.ACL = acl;

    try {
        await todo.SaveAsync();
        return todo;
    } catch (Exception ex) {
        Console.WriteLine("Error saving private todo: " + ex.Message);
        return null;
    }
}
public async Task<ParseObject> CreatePrivateTodoAsync(string title, ParseUser ownerUser) {
    var todo = new ParseObject("Todo");
    todo["title"] = title;

    // Create an ACL granting read/write access only to the owner
    var acl = new ParseACL(ownerUser);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    todo.ACL = acl;

    try {
        await todo.SaveAsync();
        return todo;
    } catch (Exception ex) {
        Console.WriteLine("Error saving private todo: " + ex.Message);
        return null;
    }
}
﻿
Cuando guardas el objeto, tiene un ACL que impide que cualquier persona excepto el usuario especificado lo lea o lo modifique.
Permisos a Nivel de Clase (CLPs)
Los CLPs rigen los permisos predeterminados de toda una clase, como si la clase es legible o escribible públicamente, 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 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.
Estos permisos establecen la línea base, mientras que los ACLs ajustan los permisos para objetos individuales. Un modelo de seguridad robusto combina típicamente tanto CLPs (restricciones amplias) como ACLs (restricciones detalladas por objeto). Para más información, ve a Directrices de Seguridad de la Aplicación.﻿
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 servidores o infraestructura.
Al escribir Código en la Nube, puedes extender tu backend de Back4app con lógica de negocio adicional, validaciones, disparadores e integraciones que se ejecutan de manera segura y eficiente en el Parse Server.
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 (o app.js) archivo. 
Este archivo se despliega luego en tu proyecto de Back4app, que se ejecuta dentro del entorno de Parse Server. 
Dado que estas funciones y disparadores se ejecutan en el servidor, puedes confiar en que manejan lógica confidencial, procesan datos sensibles o realizan llamadas a la API solo del backend, procesos que quizás no quieras exponer directamente al cliente.
Todo el Código en la Nube para tu aplicación de Back4app se ejecuta dentro del Parse Server que es gestionado por Back4app, por lo que no tienes que preocuparte por el mantenimiento del servidor, la escalabilidad o la provisión.
Cada vez que actualizas y despliegas tu archivo main.js, el servidor Parse en ejecución se actualiza con tu último código.
Estructura del archivo main.js
Un típico main.js podría contener:
Declaraciones de require para cualquier módulo necesario (paquetes NPM, módulos integrados de Node, u otros archivos de código en la nube).
Definiciones de funciones en la nube usando Parse.Cloud.define().
Triggers como Parse.Cloud.beforeSave(), Parse.Cloud.afterSave(), etc.
Módulos NPM que instalaste (si es necesario).
main.js
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
Con la capacidad de instalar y usar módulos NPM, el código en la nube se vuelve increíblemente flexible, permitiéndote integrar con APIs externas, realizar transformaciones de datos o ejecutar lógica compleja del lado del servidor.
Casos de Uso Típicos
Lógica de Negocios: Por ejemplo, agregar datos para análisis o realizar cálculos antes de guardar en la base de datos.
Validaciones de Datos: Asegurarse de que ciertos campos estén presentes o que un usuario tenga los permisos correctos antes de guardar o eliminar un registro.
Disparadores: Realizar acciones cuando los datos cambian (por ejemplo, enviar una notificación cuando un usuario actualiza su perfil).
Integraciones: Conectar con APIs o servicios de terceros.
Aplicación de Seguridad: Validar y sanitizar entradas para aplicar seguridad antes de realizar operaciones sensibles.
Despliega Tu Función
A continuación se muestra una función simple de Cloud Code que calcula la longitud de una cadena de texto enviada desde el cliente:
main.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 Back4app CLI:
1 - Instalar el CLI:
Para Linux/MacOS:
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
﻿
Para Windows:
Descarga el b4a.exe archivo de la página de lanzamientos.
2 - Configura tu clave de cuenta:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
3 - Despliega tu código en la nube:
Bash
b4a deploy
b4a deploy
﻿
Desplegando a través del Panel de Control:
En el panel de control de tu aplicación, ve a Cloud Code > Functions.
Copia/pega la función en el main.js editor.
Haz clic en Deploy.
Llamando a Tu Función
Desde Blazor usando el SDK de Parse .NET:
SomeDataService.cs (calling function)
public async Task<int?> GetTextLengthAsync(string text) {
    try {
        var result = await ParseCloud.CallFunctionAsync<Dictionary<string, object>>("calculateTextLength", 
            new Dictionary<string, object> { { "text", text } });
        if(result != null && result.ContainsKey("length"))
            return Convert.ToInt32(result["length"]);
        return null;
    } catch(Exception ex) {
        Console.WriteLine("Error calling cloud function: " + ex.Message);
        return null;
    }
}
public async Task<int?> GetTextLengthAsync(string text) {
    try {
        var result = await ParseCloud.CallFunctionAsync<Dictionary<string, object>>("calculateTextLength", 
            new Dictionary<string, object> { { "text", text } });
        if(result != null && result.ContainsKey("length"))
            return Convert.ToInt32(result["length"]);
        return null;
    } catch(Exception ex) {
        Console.WriteLine("Error calling cloud function: " + ex.Message);
        return null;
    }
}
﻿
También puedes llamarlo a través de REST o GraphQL como se muestra en el tutorial de ReactJS.
Paso 5 – Configurando la Autenticación de Usuarios
Autenticación de Usuario en Back4app
Back4app aprovecha la clase Parse User como base para la autenticación. Por defecto, Parse maneja el hash de contraseñas, los tokens de sesión y el almacenamiento seguro. Esto significa que no tienes que configurar flujos de seguridad complejos manualmente.
Configurando la Autenticación de Usuario
En una aplicación Blazor, puedes crear un nuevo usuario con:
AuthService.cs
using Parse;
using System.Threading.Tasks;

public class AuthService {
    public async Task SignUpUserAsync(string username, string password, string email) {
        var user = new ParseUser() {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User signed up successfully!");
        } catch (Exception ex) {
            Console.WriteLine("Error signing up user: " + ex.Message);
        }
    }

    public async Task LogInUserAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine("User logged in: " + user.Username);
        } catch (Exception ex) {
            Console.WriteLine("Error logging in user: " + ex.Message);
        }
    }
}
using Parse;
using System.Threading.Tasks;

public class AuthService {
    public async Task SignUpUserAsync(string username, string password, string email) {
        var user = new ParseUser() {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User signed up successfully!");
        } catch (Exception ex) {
            Console.WriteLine("Error signing up user: " + ex.Message);
        }
    }

    public async Task LogInUserAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine("User logged in: " + user.Username);
        } catch (Exception ex) {
            Console.WriteLine("Error logging in user: " + ex.Message);
        }
    }
}
﻿
Gestión de Sesiones
Después de un inicio de sesión exitoso, Parse crea un token de sesión que se almacena en el objeto de usuario. En tu aplicación Blazor, puedes acceder al usuario que ha iniciado sesión actualmente:
SomeComponent.razor.cs
var currentUser = ParseUser.CurrentUser;
if (currentUser != null) {
    Console.WriteLine("Currently logged-in user: " + currentUser.Username);
} else {
    Console.WriteLine("No user is logged in");
}
var currentUser = ParseUser.CurrentUser;
if (currentUser != null) {
    Console.WriteLine("Currently logged-in user: " + currentUser.Username);
} else {
    Console.WriteLine("No user is logged in");
}
﻿
Parse maneja automáticamente las sesiones basadas en tokens en segundo plano, pero también puedes gestionarlas o revocarlas manualmente. Para cerrar sesión:
AuthService.cs (logout)
public async Task LogOutAsync() {
    await ParseUser.LogOutAsync();
    Console.WriteLine("User logged out");
}
public async Task LogOutAsync() {
    await ParseUser.LogOutAsync();
    Console.WriteLine("User logged out");
}
﻿
Integración de Inicio de Sesión Social
Back4app y Parse pueden integrarse con proveedores de OAuth populares, como Google o Facebook. 
La configuración puede variar y a menudo implica la configuración del lado del servidor o paquetes adicionales. Consulta la Documentación de Inicio de Sesión Social para instrucciones detalladas.
Dado que las aplicaciones de Blazor Server se ejecutan en ASP.NET Core, puedes integrar el inicio de sesión social utilizando proveedores de identidad de ASP.NET Core junto con Parse para una autenticación sin problemas.
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 control de Back4app.
Habilita la verificación de correo electrónico para asegurar que los nuevos usuarios verifiquen la propiedad de sus direcciones de correo electrónico.
Configura la dirección del remitente, las plantillas de correo electrónico y tu dominio personalizado si lo deseas.
Estas características mejoran la seguridad de la cuenta y la experiencia del usuario al validar la propiedad del correo electrónico y proporcionar un método seguro 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:
FileService.cs
using Parse;
using System;
using System.Threading.Tasks;

public class FileService {
    public async Task<string> UploadImageAsync(byte[] fileData, string fileName) {
        var parseFile = new ParseFile(fileName, fileData);
        try {
            await parseFile.SaveAsync();
            Console.WriteLine("File saved: " + parseFile.Url);
            return parseFile.Url;
        } catch (Exception ex) {
            Console.WriteLine("Error uploading file: " + ex.Message);
            return null;
        }
    }
}
using Parse;
using System;
using System.Threading.Tasks;

public class FileService {
    public async Task<string> UploadImageAsync(byte[] fileData, string fileName) {
        var parseFile = new ParseFile(fileName, fileData);
        try {
            await parseFile.SaveAsync();
            Console.WriteLine("File saved: " + parseFile.Url);
            return parseFile.Url;
        } catch (Exception ex) {
            Console.WriteLine("Error uploading file: " + ex.Message);
            return null;
        }
    }
}
﻿
Para adjuntar el archivo a un objeto:
FileService.cs (continued)
public async Task<ParseObject> CreatePhotoObjectAsync(byte[] fileData, string fileName) {
    var photo = new ParseObject("Photo");
    var parseFile = new ParseFile(fileName, fileData);
    photo["imageFile"] = parseFile;

    try {
        await photo.SaveAsync();
        return photo;
    } catch (Exception ex) {
        Console.WriteLine("Error creating photo object: " + ex.Message);
        return null;
    }
}
public async Task<ParseObject> CreatePhotoObjectAsync(byte[] fileData, string fileName) {
    var photo = new ParseObject("Photo");
    var parseFile = new ParseFile(fileName, fileData);
    photo["imageFile"] = parseFile;

    try {
        await photo.SaveAsync();
        return photo;
    } catch (Exception ex) {
        Console.WriteLine("Error creating photo object: " + ex.Message);
        return null;
    }
}
﻿
Recuperando la URL del archivo:
SomeComponent.razor.cs
var imageFile = photo.Get<ParseFile>("imageFile");
var imageUrl = imageFile.Url;
var imageFile = photo.Get<ParseFile>("imageFile");
var imageUrl = imageFile.Url;
﻿
Puedes mostrar esta imageUrl en tus componentes de Blazor configurándola como la fuente de un <img> etiqueta.
Seguridad de Archivos
Parse Server proporciona configuraciones flexibles para gestionar la seguridad de la carga de archivos. Usa ACLs en ParseFiles o establece configuraciones a nivel de servidor según sea necesario.
Paso 7 – Programación de Tareas con Cloud Jobs
Cloud Jobs
Cloud Jobs en Back4app te permiten programar y ejecutar tareas rutinarias en tu backend - como limpiar datos antiguos o enviar un correo electrónico diario de resumen. Un Cloud Job típico podría verse así:
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);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
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);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Despliega tu Cloud Code con el nuevo trabajo (a través de CLI o el panel de control).
Ve al Panel de Control de Back4app > Configuraciones de la App > Configuraciones del Servidor > Tareas en Segundo Plano.
Programa el trabajo para que se ejecute diariamente o en el intervalo que mejor se adapte a tus necesidades.
﻿
Los trabajos en la nube te permiten automatizar el mantenimiento en segundo plano u otros procesos periódicos sin requerir intervención manual.
Paso 8 – Integrando Webhooks
Los Webhooks permiten que tu aplicación 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 panel de Back4app > Más > WebHooks y luego haz clic en Agregar Webhook.
Configura un endpoint (por ejemplo, https://your-external-service.com/webhook-endpoint).
Configura los disparadores para especificar qué eventos en tus clases de Back4app o funciones de Cloud Code activarán el webhook.
Por ejemplo, si deseas notificar a un canal de Slack cada vez que se crea un nuevo Todo:
Crea una aplicación de Slack que acepte webhooks entrantes.
Copia la URL del webhook de Slack.
En tu panel de Back4app, establece el endpoint a esa URL de Slack para el evento “Nuevo registro en la clase Todo.”
También puedes agregar encabezados HTTP personalizados o cargas útiles si es necesario.
También puedes definir Webhooks en Cloud Code haciendo solicitudes HTTP personalizadas en disparadores como beforeSave, afterSave.
Paso 9 – 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 rutinarias de datos sin escribir ningún código. 
Proporciona una interfaz centrada en el modelo, amigable para el usuario 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
Habilítala yendo a App Dashboard > Más > Admin App y haciendo clic en el botón “Habilitar Aplicación de Administración.”
Crea un Primer Usuario Administrador (nombre de usuario/contraseña), lo que genera automáticamente un nuevo rol (B4aAdminUser) y clases (B4aSetting, B4aMenuItem y B4aCustomField) en el esquema de tu aplicación.
Elige un Subdominio para acceder a la interfaz de administración y completa la configuración.
Inicia Sesión utilizando las credenciales de administrador que creaste para acceder a tu nuevo panel de administración de la Aplicación.
Una vez habilitada, la Aplicación de Administración de Back4app facilita la visualización, edición o eliminación de registros de tu 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, has:
Creado un backend seguro para una aplicación Blazor en Back4app.
Configurado una base de datos con esquemas de clase, tipos de datos y relaciones.
Integrado consultas en tiempo real donde sea aplicable 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 frontend de Blazor y un robusto backend de Back4app, ahora estás bien equipado para desarrollar aplicaciones web 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. ¡Feliz codificación!
Próximos Pasos
Construye una aplicación Blazor lista para producción extendiendo este backend para manejar modelos de datos más complejos, estrategias de caché y optimizaciones de rendimiento.
Integra características avanzadas como flujos de autenticación especializados, control de acceso basado en roles o APIs externas.
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. Combina las técnicas aprendidas aquí con APIs de terceros para crear aplicaciones complejas del mundo real.
﻿
Actualizado 11 Feb 2025
¿Esta página le fue útil?
¿Cómo construir una aplicación CRUD con ReactJS?
¿Cómo construir un backend para htmx?