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

41min
Introducción
En este tutorial, aprenderás cómo construir un backend para Flutter utilizando Back4app, un backend como servicio (BaaS) de código abierto y confiable. 
Recorreremos la integración de características esenciales de Back4app—como la gestión de bases de datos, funciones en la nube, APIs RESTful, APIs GraphQL y autenticación de usuarios—en tu proyecto de Flutter. 
También descubrirás cómo manejar actualizaciones en tiempo real utilizando Consultas en Vivo. Al usar los potentes servidores backend de Back4app, puedes omitir gran parte de la configuración manual y concentrarte en crear una aplicación dinámica de Flutter.
Esta guía mostrará a los desarrolladores de Flutter cómo configurar una estructura de backend segura, escalable y robusta que se comunique sin esfuerzo con tu lado del cliente. 
También destacaremos las ventajas de dejar que Back4app maneje el trabajo pesado—como el alojamiento, la autenticación de usuarios y la lógica del servidor—para que puedas beneficiarte de características como escalado automático, seguridad avanzada y mantenimiento simplificado. 
Si tienes un proyecto de Flutter y quieres ahorrar incontables horas en la configuración del backend, este es el lugar adecuado para comenzar.
Al final de este tutorial, entenderás el tipo de backend que puedes crear con Back4app y estarás listo para extender tus servicios de backend para una aplicación lista para producción o integrar funcionalidades más complejas, como APIs externas y autenticación de usuarios avanzada. 
¡Comencemos!
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 Flutter
 Asegúrate de tener el SDK de Flutter instalado y configurado. Además, confirma que tienes un IDE (como Android Studio o VS Code) configurado para Flutter.
Entorno de Dart (lenguaje de programación)
Generalmente esto se instala junto con Flutter. Asegúrate de poder importar dart paquetes sin errores.
Familiaridad con los fundamentos de Flutter
 Documentación oficial de Flutter.
Si eres nuevo en Flutter, revisa la documentación oficial o un tutorial para principiantes antes de comenzar.
Asegúrate de tener todos estos requisitos previos en su lugar. Tener tu proyecto de Back4app configurado y tu entorno local de Flutter configurado te ayudará a seguir más fácilmente.
Paso 1 – Crear un nuevo proyecto en Back4App y conectar
Crear un nuevo proyecto
El primer paso para construir tu backend de Flutter 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, “Flutter-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 que discutiremos.
Instala e Inicializa el SDK de Parse en tu Aplicación Flutter
Back4app se basa en la Plataforma Parse para gestionar tus datos, actualizaciones en tiempo real, autenticación de usuarios y más. Para conectar tu proyecto Flutter a Back4app, sigue estos pasos:
Agrega el SDK de Parse Flutter a tu aplicación:
YAML
dependencies:
  parse_server_sdk_flutter: ^4.0.0
dependencies:
  parse_server_sdk_flutter: ^4.0.0
﻿
Importa el paquete Parse en tu main.dart (o donde inicialices tu aplicación):
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
﻿
En tu panel de Back4app, ve a la sección de Seguridad y Claves de tu aplicación para encontrar tu ID de Aplicación, Clave de Cliente, y URL del Servidor Parse. Reemplaza los marcadores de posición anteriores con tus propias credenciales. Con esta inicialización, cada solicitud de tu aplicación Flutter se enruta de forma segura a tu instancia de Back4app.
Recuerda que la clave maestra nunca debe ser utilizada en el lado del cliente de tu aplicación Flutter. Si necesitas la clave maestra, mantenla en el servidor o en un entorno seguro.
Paso 2 – Configuración de la Base de Datos
Creando un Modelo de Datos
Una vez que tu aplicación Flutter esté conectada a Back4app, puedes comenzar a diseñar el esquema de tu base de datos. Puedes hacer esto manualmente desde el panel de Back4app:
Navega a la sección “Base de Datos” en tu panel.
Crea una nueva clase (por ejemplo, “Todo”), y agrega columnas relevantes (por ejemplo, título, estáCompletado).
Crear Nueva Clase
﻿
Back4app también proporciona un Agente de IA para ayudar con la creación automática de esquemas:
Abre el Agente de IA desde tu Panel de Control de la App o el menú.
Describe tu modelo de datos en un lenguaje simple (por ejemplo, “Crea una nueva App de ToDo con un esquema de clase completo.”).
Deja que el Agente de IA cree el esquema por ti.
﻿
Esto simplifica la configuración de la arquitectura de datos. Si deseas que los campos se creen automáticamente, simplemente puedes comenzar a guardar objetos desde tu app: Parse admite la creación de esquemas sobre la marcha.
Creando un Modelo de Datos Usando el Agente de IA
Si eliges usar el Agente de IA de Back4app, solo proporciona una breve descripción, y él construirá o sugerirá un esquema para ti. Esta es una excelente manera de acelerar la fase inicial de modelado de datos de tu proyecto de flutter.
Leer y Escribir Datos Usando Flutter Parse SDK
A continuación se muestra un ejemplo simple que demuestra cómo crear y recuperar objetos usando el Parse Flutter SDK.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
﻿
Con esto, puedes interactuar directamente con tu base de datos de Back4app desde tu aplicación Flutter. Simplemente llama a createTodoItem('Feed the cat', false) o fetchTodos() para escribir y leer datos.
Lectura y Escritura de Datos Usando la API REST
Si necesitas integrarte con otros servicios o prefieres un enfoque más tradicional, aún puedes usar 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
﻿
Lectura y Escritura de Datos Usando la API GraphQL
Back4app también ofrece un endpoint 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
    }
  }
}
﻿
Esto te da flexibilidad para construir el enfoque que mejor funcione para tu aplicación Flutter.
Trabajando con Consultas en Vivo
Back4app proporciona Consultas en Vivo para que puedas recibir actualizaciones en tiempo real de tus datos. Habilita las Consultas en Vivo en el panel de control de Back4app (Configuración del Servidor) y luego utiliza el cliente Parse LiveQuery para Flutter.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
﻿
Con esta suscripción, puedes escuchar los cambios de datos a medida que ocurren. Esto es fantástico para construir aplicaciones colaborativas donde múltiples usuarios ven actualizaciones de datos en vivo. Una vez que se activa la recarga en caliente, tu suscripción permanecerá a menos que la aplicación se reinicie.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
¿Qué son ACLs y CLPs?
Back4app utiliza ACLs (Listas de Control de Acceso) y CLPs (Permisos a Nivel de Clase) para restringir quién puede leer o escribir datos tanto a nivel de objeto como de clase. Esta capa asegura que tus datos estén protegidos contra accesos no autorizados.
Configurando Permisos a Nivel de Clase
En tu panel de Back4app, ve a Database y selecciona una clase (por ejemplo, “Todo”).
Navega a Class-Level Permissions.
Establece valores predeterminados (por ejemplo, solo los usuarios autenticados pueden crear nuevos objetos).
﻿
Configurando ACLs en Código
También puedes aplicar ACLs a nivel de objeto desde el código de Flutter:
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
﻿
Al combinar CLPs y ACLs, puedes asegurarte de que solo las personas o roles correctos puedan acceder o modificar datos específicos.
Paso 4 – Escribiendo Funciones de Cloud Code
¿Por qué Cloud Code?
Cloud Code te permite ejecutar lógica del lado del servidor sin configurar manualmente ningún servidor backend. Esto es perfecto para validar datos, integrarse con servicios externos o hacer cumplir ciertas reglas en tu backend como servicio (BaaS).
Ejemplo de Función
Aquí hay un ejemplo de Función en la Nube que calcula la longitud de un texto:
JS
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Puedes desplegar este código a través de la CLI de Back4app o en el panel de tu aplicación bajo Cloud Code.
Despliegue
Usando la CLI de Back4app:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Usando el Panel:
En el panel de tu aplicación, ve a Cloud Code > Functions.
Pega el código JavaScript.
Haz clic en Desplegar.
﻿
Llamando a Cloud Code desde Flutter
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
﻿
Este enfoque seguro asegura que la lógica sensible permanezca en el servidor, mientras que tu aplicación Flutter simplemente realiza solicitudes.
Paso 5 – Configurando la Autenticación
Habilitar la Autenticación de Usuarios
Back4app utiliza la Parse.User clase para manejar el registro e inicio de sesión de usuarios. Por defecto, Parse se encarga del hash de contraseñas, tokens de sesión y almacenamiento seguro.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
﻿
Inicio de sesión social
Back4app soporta integraciones con Google, Apple, Facebook y más. Cada proveedor tiene un enfoque específico y puede requerir bibliotecas adicionales (por ejemplo, para el inicio de sesión de Facebook o Google). Luego puedes llamar a:
Dart
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
﻿
Ajusta los parámetros de acuerdo con la documentación del proveedor.
Paso 6 – Manejo del almacenamiento de archivos
Configurando el almacenamiento de archivos
Puedes almacenar imágenes, documentos u otros archivos multimedia usando ParseFile. Back4app asegura estos archivos y proporciona una URL para su recuperación.
Dart
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
﻿
Consideraciones de Seguridad
Puedes definir quién tiene acceso a los archivos (público, usuarios autenticados o restringido) combinando la seguridad a nivel de archivo con ACLs. Esto asegura que los datos de tu archivo permanezcan seguros.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Por qué son Importantes
La verificación de correo electrónico confirma que un usuario posee la dirección de correo electrónico proporcionada, mientras que los flujos de restablecimiento de contraseña mejoran la experiencia del usuario y la seguridad.
Configuración del Panel de Control
Ve a la Configuración de Correo Electrónico de tu aplicación en el panel de control de Back4app.
Habilita Verificación de Correo Electrónico y Restablecimiento de Contraseña.
Configura plantillas de correo electrónico o tu dominio personalizado si es necesario.
Estas configuraciones permiten que tu aplicación Flutter maneje automáticamente las verificaciones de propiedad del usuario y la recuperación de contraseñas.
Implementación en Flutter
Dart
final user = ParseUser('testuser', 'password123', '[email protected]');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('[email protected]');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
final user = ParseUser('testuser', 'password123', 'test@example.com');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('test@example.com');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
﻿
Paso 8 – Programación de Tareas con Cloud Jobs
Cloud Jobs
Es posible que desees programar tareas recurrentes (como limpiar datos antiguos o enviar correos electrónicos periódicos). Cloud Jobs te permiten hacer precisamente eso:
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 este código, luego ve a Configuración de la App > Configuración del Servidor > Trabajos en Segundo Plano en tu panel de Back4app para programarlo.
Programando un Trabajo en la Nube
﻿
Paso 9 – Integrando Webhooks
¿Qué son los Webhooks?
Los webhooks permiten que tu aplicación de Back4app envíe solicitudes HTTP a un servicio externo cuando ocurren ciertos eventos (como guardar un nuevo objeto). Esto es ideal para integrarse con herramientas de terceros.
Ve a Más > WebHooks en tu panel de Back4app y Agregar Webhook.
Configura tu endpoint y disparadores (por ejemplo, “Nuevo registro en Todo”).
Agregando un Webhook
﻿
También puedes configurar manualmente los webhooks en Cloud Code haciendo solicitudes HTTP en los disparadores beforeSave o afterSave.
BeforeSave WebHook
﻿
Paso 10 – Explorando el Panel de Administración de Back4App
Dónde encontrarlo
La Aplicación de Administración de Back4app es una interfaz fácil de usar que permite a los miembros del equipo no técnicos gestionar datos (operaciones CRUD, tareas de datos, etc.) sin necesidad de abrir el Panel de Control de Parse.
Ve a Panel de la Aplicación > Más > Aplicación de Administración.
Haz clic en Habilitar Aplicación de Administración.
Habilitar Aplicación de Administración
﻿
Crearás un usuario administrador, elegirás un subdominio y iniciarás sesión con las credenciales recién creadas. La Aplicación de Administración ayuda con revisiones y modificaciones rápidas de datos.
Conclusión
En este tutorial, aprendiste cómo construir un backend para Flutter utilizando Back4app y el SDK de Parse para Flutter. 
Creaste clases, almacenaste datos, configuraste consultas en tiempo real, aplicaste seguridad con ACLs y CLPs, escribiste funciones en la nube, programaste tareas, integraste webhooks y exploraste el Panel de Administración de Back4app. 
Este enfoque acelera el desarrollo al permitirte concentrarte en el lado del cliente de Flutter en lugar de en la compleja configuración del servidor.
La cadena final que tienes ahora es un backend funcional y seguro que aprovecha APIs RESTful, autenticación de usuarios y fácil manipulación de datos. 
Puedes integrar características más avanzadas en cualquier momento, como funciones en la nube adicionales, llamadas a APIs externas o roles personalizados. 
Próximos Pasos
Prepárate para producción: Implementa almacenamiento en caché avanzado, análisis o controles de acceso basados en roles.
Extiende tu aplicación: Integra servicios de terceros o construye más funciones en la nube para lógica de negocio especializada.
Consulta la documentación de Back4app: Explora seguridad avanzada, ajuste de rendimiento, análisis de registros y más.
Aprende más: Consulta tutoriales para aplicaciones de chat en vivo, servicios basados en ubicación o estructuras de datos más complejas. Combínalos con tu proyecto de Flutter para casos de uso del mundo real.
Al continuar refinando esta configuración, transformarás tu aplicación Flutter en una solución poderosa y escalable construida sobre un robusto servicio de backend. ¡Feliz codificación!
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Objective-C?
¿Cómo construir un backend para Gatsby?