¿Cómo construir un backend para una aplicación móvil?

En este artículo, aprenderá qué es un backend para una aplicación móvil y todo lo que necesita saber para construir su backend.

Veremos las diferencias entre un backend y un frontend, diferentes tipos de backend, aprenderemos sobre las funcionalidades del backend móvil y los costos para desarrollar un backend.

Por último, aprenderemos cómo crear un backend para una aplicación móvil simple en Back4app, uno de los mejores proveedores de MBaaS.

Diferencias entre un frontend y un backend

Los términos frontend y backend hacen referencia a la separación de intereses entre la capa de presentación y la capa de acceso a datos.

La forma más fácil de comprender sus diferencias es visualizar un iceberg. La interfaz está por encima del nivel del agua y es todo con lo que un usuario puede ver e interactuar. El backend, por otro lado, es la parte del iceberg que está bajo el agua. Es la lógica subyacente la que impulsa el negocio.

Frontend

Un frontend es una interfaz gráfica de usuario de un sitio web, una aplicación móvil o cualquier otro tipo de cliente con el que un usuario pueda interactuar. El frontend incluye todos los aspectos visuales de una aplicación, incluido el diseño, los menús, los textos, las imágenes, los videos, etc. Con la mayoría de los proyectos, representa alrededor del 20% del esfuerzo total y no es repetitivo.

Los desarrolladores frontend deben encargarse de:

• Diseño de respuesta
• Rendimiento de la aplicación
• Compatibilidad entre navegadores
• Problemas de accesibilidad
• Optimización SEO

Las interfaces web generalmente se implementan con herramientas como HTML, CSS, JavaScript y WebAssembly. Las aplicaciones nativas de Android están escritas en Java/Kotlin, mientras que las aplicaciones nativas de iOS usan Objective-C y Swift.

En los últimos años, muchos desarrolladores frontend adaptaron herramientas como React Native, Vue y Svelte Native para simplificar aún más el proceso de desarrollo y hacer que la misma base de código funcione en diferentes plataformas.

Las interfaces se pueden “implementar” en servicios como Google Play, App Store, Vercel, Netlify.

Backend

El desarrollo backend o del lado del servidor es la práctica de desarrollar la capa de acceso a datos. El backend es la conexión entre la base de datos y el frontend. La mayoría de los backend proporcionan una interfaz de capa de aplicación (API), que un frontend puede usar para obtener y almacenar datos.

Los datos generalmente se intercambian en formato JSON o GraphQL. Un backend suele representar alrededor del 80% del trabajo y es repetitivo. Por ejemplo, casi todos los proyectos requieren autenticación, autorización, administración de bases de datos, etc.

Los desarrolladores backend son responsables de:

• Gestión de base de datos
• Lógica de negocio de la aplicación
• Escalabilidad, alta disponibilidad
• Problemas de seguridad y copias de seguridad

Los desarrolladores backend suelen trabajar con lenguajes de programación como Python, JavaScript (Node.js), Ruby, C#, Java y Go. En el momento de escribir este artículo, la arquitectura de backend más popular es Modelo-Vista-Controlador (MVC), que ha sido adoptada por muchos marcos web como Django y Laravel.

El componente más importante de un backend es su base de datos. Tenemos diferentes tipos de bases de datos que podemos dividir en tres categorías generales:

• Bases de datos SQL
• Bases de datos NoSQL
• Bases de datos de múltiples paradigmas

Cada uno tiene sus pros y sus contras, que deben tenerse en cuenta al iniciar un proyecto.

Un backend se puede implementar en diferentes plataformas según el nivel de abstracción deseado. Por ejemplo, puede usar su propio servidor, IaaS (AWS, GCE, Azure), PaaS (Heroku, Digital Ocean App Service) o BaaS (Back4app, Firebase, AWS Amplify).

Continúe leyendo para saber más sobre el desarrollo de backend de aplicaciones móviles.

¿Qué es un backend para una aplicación móvil?

Un backend para una aplicación móvil es la parte de la aplicación que se ejecuta en un servidor, en lugar de en el propio dispositivo. El backend proporciona las funcionalidades que la aplicación necesita para almacenar y administrar datos, autenticar usuarios, procesar y analizar datos y comunicarse con otros sistemas o servicios.

Un backend puede tomar muchas formas, como un servidor que se ejecuta en un servicio en la nube, una base de datos o una API. Proporciona la infraestructura y las herramientas necesarias que la aplicación necesita para funcionar correctamente y permite que la aplicación brinde una experiencia de usuario rica y atractiva.

¿Qué funciones proporciona un backend móvil?

Un backend para una aplicación móvil generalmente proporciona las siguientes funcionalidades:

• Almacenamiento y gestión de datos
• Procesamiento y análisis de datos
• Autorización de autenticación
• Sincronización entre múltiples dispositivos
• Capacidad de integración con otros sistemas y servicios.
• Administrar tareas del lado del servidor
• Análisis y Monitoreo
• Notificaciones push

¿Una aplicación móvil necesita un backend?

Respuesta corta: si su aplicación funciona localmente (sin conexión a Internet), por lo general no necesita un backend, pero esto no significa que su aplicación no pueda beneficiarse de un backend.

Para comprender mejor esta respuesta, echemos un vistazo a algunas de las aplicaciones que usamos en la vida cotidiana.

Aplicaciones que no necesitan backend:

• Calculadora
• Calendario y reloj
• Cámara y galería
• Grabadora de voz
• Juegos para un solo jugador

Aplicaciones que necesitan un backend:

• Aplicaciones de comercio electrónico: se requiere un backend para realizar un seguimiento del inventario, procesar pedidos, etc.
• Aplicaciones de transporte: un backend permite el procesamiento de boletos, información sobre retrasos, etc.
• Aplicaciones de mensajería: se utiliza un backend para transferir mensajes de un dispositivo a otro
• Aplicaciones meteorológicas: se requiere un backend para obtener información meteorológica actual

Ahora, pensemos en cómo un backend podría mejorar las aplicaciones enumeradas anteriormente:

• Calculadora: podría usar un backend para descargar cálculos complejos a un servidor remoto
• Calendario y reloj: podría almacenar eventos en una base de datos y sincronizarlos entre dispositivos
• Cámara: podría usar un servicio de backend para corregir distorsiones, iluminación, etcétera.
• Grabadora de voz: podría usar un servicio de backend para suprimir el ruido
• Juegos para un solo jugador: podrían almacenar las puntuaciones de los usuarios en una base de datos y mostrar una tabla de clasificación

Debido a los grandes beneficios que ofrecen los backend, casi todas las aplicaciones móviles tienen un backend. Si no fuera por el almacenamiento de datos, el backend permite que las aplicaciones móviles recopilen análisis, envíen notificaciones automáticas, supervisen aplicaciones, recopilen informes de fallas y más. Si desea tener éxito, lo más probable es que necesite un backend.

¿Cuáles son los tipos de backend?

Según el tipo de su aplicación, hay varios tipos de backend entre los que puede elegir. En términos generales, podemos dividirlos en tres grupos en función de su nivel de abstracción:

1. Software como servicio (SaaS) o servicios de terceros
2. Backend móvil como servicio (MBaaS)
3. Backend personalizados

Echemos un vistazo a cada uno de ellos.

Software como servicio (SaaS) o servicios de terceros

El software como servicio (SaaS) es un modelo de entrega de software en el que un proveedor externo aloja una aplicación de software y la pone a disposición de los clientes a través de Internet.

Las soluciones SaaS generalmente requieren que sus clientes paguen una tarifa de suscripción mensual o anual. Este tipo de backend es el más fácil de usar y le permite ponerlo en funcionamiento con unos pocos clics.

La desventaja de este tipo de backend es que lo más probable es que no encuentre un SaaS que cumpla con todos los requisitos de su proyecto. Para construir un backend del mundo real, probablemente tendrá que combinar varias soluciones SaaS.

Algunos ejemplos de SaaS incluyen:

• WordPress (Sistema de gestión de contenidos)
• MailChimp (Software de gestión y email marketing)
• Salesforce (Software de gestión de relaciones con los clientes)
• Shopify (Plataforma de comercio electrónico)
• Dropbox (Alojamiento de archivos)

Backend móvil como servicio (MBaaS)

El Backend como Servicio (BaaS, del inglés “Backend as a Service”) es una plataforma que automatiza el desarrollo del backend y se encarga de la infraestructura de la nube.

Además de eso, proporciona funciones como administración de usuarios, notificaciones por correo electrónico, notificaciones automáticas, funciones de código en la nube, integraciones de redes sociales, almacenamiento de archivos y pagos.

Esto permite a los desarrolladores centrarse en el negocio principal y construir la interfaz sin preocuparse por la infraestructura y el backend subyacente. La interfaz generalmente se desarrolla a través de API y SDK especializados ofrecidos por el proveedor de BaaS. Esto hace que las aplicaciones sean menos complejas y más fáciles de mantener.

Los beneficios de usar un backend como servicio incluyen una velocidad de desarrollo más rápida, costos de ingeniería más bajos y enfoque en el negocio principal.

Algunos ejemplos de BaaS incluyen:

• Back4app
• Firebase
• AWS Amplify
• Apple Cloudkit

¿Desea saber más sobre BaaS y MBaaS? Eche un vistazo a ¿Qué es BaaS?

Backend personalizado

Un backend personalizado es la opción más poderosa y flexible. Le ofrece un control total y le permite implementar funciones que no se pueden implementar con una solución SaaS o MBaaS.

Su mayor inconveniente es su costo y tiempo de construcción. Al usar este enfoque, también será totalmente responsable del rendimiento y la seguridad de su backend.

La creación de un backend personalizado suele llevar meses y requiere un desarrollador de backend experto o incluso un equipo de desarrolladores de backend.

Marcos populares para construir backend personalizados:

• Django
• Laravel
• Express.js
• Ruby on Rails
• Spring Boot

Para obtener más información acerca de los marcos de backend, eche un vistazo a los 10 mejores marcos de backend.

¿Cuánto cuesta hacer un backend de aplicación móvil?

No existe una fórmula simple para calcular el costo del backend de una aplicación móvil. El costo varía según la complejidad de la aplicación, la cantidad de funciones, su escalabilidad, rendimiento, etc.

Costo de SaaS

SaaS suele ser la opción más barata por la que puede optar. Los productos SaaS suelen seguir un modelo de precios sencillo con tarifas de suscripción mensuales o anuales. Algunos proveedores de SaaS también ofrecen diferentes niveles de precios según el tamaño de su empresa.

Costo de MBaaS

Construir un backend con MBaaS es realmente económico en comparación con un backend personalizado. Le permite reducir considerablemente el costo de desarrollo y no tener que preocuparse por la infraestructura o contratar un equipo de ingenieros de backend especializados. ¡Esto le ahorra mucho dinero!

La mayoría de los proveedores de MBaaS vienen con diferentes niveles de precios según el tamaño de su aplicación. Al usar MBaaS, puede esperar pagar entre $15 y $500 por mes.

Costo de backend personalizado

El desarrollo de backend personalizado es la opción más cara. Al elegir esta opción, deberá reunir un equipo de desarrolladores calificados y cuidar la infraestructura de su backend.

Los precios para construir un backend personalizado generalmente oscilan entre unos pocos miles de dólares y decenas de miles de dólares, según los requisitos del proyecto.

Dado que implementar un backend personalizado es una tarea difícil, las empresas suelen subcontratarlo a empresas especializadas en desarrollo de software.

¿Cómo construir un backend para una aplicación móvil usando MBaaS?

En esta sección del tutorial, veremos cómo desarrollar un backend para una aplicación móvil usando Back4app.

¿Qué es Back4app?

Back4app es una de las mejores soluciones Backend as a Service (BaaS) de código abierto del mercado. Ofrece una amplia gama de funciones y beneficios a sus usuarios, lo que permite a los desarrolladores crear rápidamente aplicaciones web y móviles.

Al usar Back4app, podrá concentrarse en el negocio principal en lugar de preocuparse por el backend o la infraestructura subyacente.

La solución viene con un panel rico en funciones y fácil de usar y una interfaz de línea de comandos (CLI). ¡También proporcionan SDK para todas sus herramientas favoritas como Flutter, React Native, Node.js, Angular, Android, iOS y más!

Las características clave de Back4app incluyen:

• Base de datos tipo hoja de cálculo
• API REST y GraphQL
• Consultas en vivo
• Autenticación (incluida la autenticación social)
• Alojamiento escalable
• Notificaciones push y por correo electrónico

Para obtener más información sobre sus características, consulte las características de Back4app.

Back4app sigue un modelo de precios simple y directo que puede adaptarse a una aplicación de cualquier tamaño. Ofrecen un generoso plan gratuito (no se requiere tarjeta de crédito) que es excelente para crear prototipos y probar la plataforma. Incluye:

• 25k solicitudes
• Almacenamiento de datos de 250 MB
• Transferencia de 1 GB
• 1 GB de almacenamiento de archivos

Para obtener más información sobre los precios de Back4app, consulte la página Precios.

Introducción al proyecto

Vamos a construir un backend para una aplicación de noticias simple. La aplicación permitirá a los editores crear, actualizar y eliminar artículos. Para que la administración sea lo más fácil posible, vamos a habilitar la aplicación de administración de Back4app.

Nos ocuparemos de la seguridad del backend y mostraremos cómo usar la API REST del backend. El backend se construirá con una cantidad mínima de código.

Requisitos previos:

• Comprensión básica de backend como servicio (BaaS)
• Comprensión básica de bases de datos (y relaciones entre modelos)
• Comprensión básica de las solicitudes y respuestas HTTP
• Comprender la sintaxis JSON

Objetivos:

Al final de este tutorial, podrá:

• Crear e implemente un backend simple en Back4app
• Ser capaz de estructurar su propia base de datos
• Comprender los conceptos básicos de Parse Platform Security
• Saber cómo realizar operaciones CRUD a través de la API REST

Creación de la aplicación

Los siguientes pasos requerirán que tenga una cuenta Back4app. Si ya lo tiene, inicie sesión; de lo contrario, regístrese para obtener la cuenta gratuita.

Para trabajar con Back4app primero necesitamos crear una aplicación. Al iniciar sesión en su tablero, verá la lista de sus aplicaciones. Haga clic en “Crear una nueva aplicación” para crear una nueva aplicación.

Dele un nombre personalizado y luego haga clic en “Continuar”.

Back4app se tomará unos minutos para preparar todo lo necesario para su aplicación, como la base de datos, la capa de la aplicación, el escalado, las copias de seguridad y la seguridad.

Una vez que su aplicación esté lista, será redirigido al panel de su aplicación.

Base de datos

En esta sección del tutorial, crearemos todos los modelos de base de datos necesarios.

Como se mencionó en la introducción del proyecto, vamos a crear una aplicación de noticias simple. Nuestra base de datos va a estar compuesta por los siguientes modelos:

• Article representa un artículo de noticias.
• ArticleCategory representa una categoría de artículo (por ejemplo, deportes, entretenimiento). Un artículo puede pertenecer a una categoría.
• ArticleTag rrepresenta un hashtag de artículo (por ejemplo, cosméticos, salud, belleza). Un artículo puede tener múltiples hashtags.

Esta estructura de base de datos nos permitirá posteriormente filtrar los artículos en función de categorías o etiquetas. Dibujemos un diagrama entidad-relación (DER) para comprender mejor las relaciones entre los modelos:

Ahora, vamos a crear los modelos.

Comience por crear el modelo  ArticleCategory model. En la parte superior izquierda de la pantalla, haga clic en “Crear una clase”, asígnele el nombre  ArticleCategory y agregue los siguientes campos::

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

A continuación, cree otra clase llamada  ArticleTag con los siguientes detalles::

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Por último, cree otra clase llamada Article con los siguientes campos:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | title       | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| String                      | content     | <leave blank> | yes      |
+-----------------------------+-------------+--------------+-----------+
| Pointer -> ArticleCategory  | category    | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ArticleTag      | tags        | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Eso es todo para la arquitectura de la base de datos. Ahora agreguemos algunos datos de muestra.

Para facilitar un poco las cosas, he generado algunos datos que puede importar. Para importar un conjunto de datos, seleccione la clase en el lado izquierdo de la pantalla y luego haga clic en los tres puntos en el lado derecho de la pantalla. Seleccione “Importar” > “Datos de clase” y seleccione el archivo apropiado.

Para descargar los conjuntos de datos JSON, vaya al repositorio back4app-mobile de GitHub, haga clic en “Código” y luego en “Descargar ZIP”.

Importe los archivos JSON en el siguiente orden:

1. Usuario
2. CategoriaArtículo
3. EtiquetaArtículo
4. Artículo

Panel de Admin

Para facilitar un poco la administración, habilitaremos la aplicación Admin. La aplicación de administración es una herramienta basada en un navegador web diseñada para administrar los datos de la aplicación mediante una interfaz de usuario no tecnológica.

Navegue hasta el panel de su aplicación, haga clic en “Más” > “Aplicación de administración” y luego haga clic en el botón “Habilitar aplicación de administración”.

Elija un nombre de usuario y una contraseña. Yo usaré:

Username: admin
Password: complexpassword123

Luego, elija un nombre de dominio que le gustaría usar para acceder a su panel de administración. Yo usaré:

mobile-backend.admin.back4app.com

Genial, ahora puede iniciar sesión en su panel de administración en el dominio seleccionado. Para obtener más información sobre la aplicación de administración Back4app, consulte los documentos oficiales.

Asegurando la aplicación

Para que nuestra aplicación sea segura, debemos realizar lo siguiente:

1. No permitir que los clientes creen clases de base de datos
2. Modificar los permisos de nivel de clase (CLP, del inglés “Class Level Permissions”) 
3. Modifique los CLP para cada modelo que creamos

Invalide la creación de clases de clientes

Para invalidar la creación de clases de clientes, vaya a  “App Settings” > “Server Settings” > “Core Settings” > “Edit”, desplácese hacia abajo hasta la parte inferior de la página y desmarque  “Allow Client Class Creation”.

Modifique los CLP del modelo de usuario

Seleccione su modelo de usuario en la pestaña “Base de datos” y haga clic en los tres puntos en el lado derecho de la pantalla > “Security” > “Class Level Permissions”. TLuego haga clic en el icono de la rueda dentada y cámbielo a “Avanzado”. Desmarque todo excepto  Get y Create así:

Modifique los CLP para cada modelo que creamos

Haga algo similar para todos sus modelos personalizados  (Article, ArticleCategory, y ArticleTag). Esta vez deshabilite todo excepto Read y Find para el grupo Public de esta forma:

De esta manera, los usuarios no autenticados solo podrán encontrar y leer los artículos. Para obtener más información sobre seguridad, consulte Parse Security

Pruebas de API

En esta sección del tutorial, probaremos nuestra API utilizando la Consola API integrada.

Para abrir la Consola API REST, navegue hasta el panel de su aplicación. Seleccione “Consola” en la sección “API” y luego “REST”.

Debido a nuestras ACL/CLP, asegúrese de marcar “¿Usar clave maestra?” para que las solicitudes sean exitosas.

Recuperar

Los objetos se pueden recuperar con el tipo de solicitud GET. Para los endpoints use classes/<your_class> por ejemplo. classes/Article y haga clic en el botón “Send Query” en la parte inferior de la página.

La respuesta será algo como esto:

{
    "results": [
                {
            "objectId": "oRwkdx7KgX",
            "title": "Voting 2022 has ended!",
            "description": "The voting for year 2022 has ended, the new major is...",
            "content": "Lorem ipsum dolor sit amet...",
            "category": {
                "__type": "Pointer",
                "className": "ArticleCategory",
                "objectId": "FYxzrBlCBC"
            },
            "author": {
                "__type": "Pointer",
                "className": "_User",
                "objectId": "UZ76K07znv"
            },
            "createdAt": "2022-12-13T09:09:04.845Z",
            "updatedAt": "2022-12-13T09:09:13.297Z",
            "tags": {
                "__type": "Relation",
                "className": "ArticleTag"
            }
        },
        ... more results ...
    ]
}

Si desea obtener un resultado específico o filtrar el conjunto de consultas, eche un vistazo a los documentos.

Crear

Para crear una instancia de modelo, seleccione la solicitud  POST request y envíela a classes/<your_class>, eg. classes/Article. Con las solicitudes POST debe proporcionar parámetros de consulta. Por ejemplo:

{
   "title": "Another article",
   "content": "This is another test article added via the API",
   "category": {
      "__type": "Pointer",
      "className" :"ArticleCategory",
      "objectId": "pPGdxPAxQA"
   },
   "author": {
      "__type": "Pointer",
      "className": "_User",
      "objectId": "LFAf3yD8w0"
   }
}

Respuesta:

{
    "objectId": "yAbmJ0sRZT",
    "createdAt": "2022-12-12T17:18:32.922Z"
}

Actualizar

Para actualizar un modelo, seleccione el tipo de solicitud  PUT y envíelo a classes/<your_class>/<object_id>, eg. classes/Article/oRwkdx7KgX. Tendrá que proporcionar parámetros de consulta que contengan datos que le gustaría cambiar:

{"description": "Back4app is cool!"}

Respuesta:

{
    "updatedAt": "2022-12-12T17:31:23.459Z"
}

Eliminar

Para eliminar una instancia de modelo, seleccione el tipo de solicitud DELETE y envíela a classes/<your_class>/<object_id>, p. classes/Article/oRwkdx7KgX.

Si la solicitud fue exitosa, se devolverá un cuerpo vacío. Para obtener más información sobre las solicitudes REST con Back4app, consulte la referencia de la API.

Pasos futuros

Nuestro backend para una aplicación móvil ahora está más o menos completo. Para conectarlo a su aplicación móvil tendrá que hacer lo siguiente:

1. Obtenga su Application ID y Client key en  “App Settings” > “Security & Keys”.
2. Instale el SDK de ParseJS adecuado (según su plataforma).
3. Use el SDK para conectarse a Back4app usando sus credenciales.
4. Utilice el SDK para enviar solicitudes

Para obtener instrucciones detalladas, eche un vistazo a nuestros documentos:

• Inicio rápido de Flutter
• Inicio rápido de React Native
• Inicio rápido de Android
• Inicio rápido de iOS

Conclusión

Los términos frontend y backend hacen referencia a la separación de intereses entre la capa de presentación y la capa de acceso a datos.

En estos días, casi todas las aplicaciones móviles tienen su propio backend debido a todas las grandes ventajas que ofrece un backend. Los backend permiten que las aplicaciones móviles recopilen análisis, envíen notificaciones automáticas, supervisen aplicaciones, recopilen informes de fallas y más.

Hay múltiples formas de construir un backend. Puede:

• Combinar múltiples productos SaaS
• Usar backend móvil como servicio (MBaaS)
• Crear un backend personalizado

El uso de MBaaS es una excelente opción, ya que es realmente económico en comparación con un backend personalizado y brinda mucha flexibilidad. Back4app es uno de los mejores proveedores de MBaaS que le permite crear un backend en cuestión de días, o incluso horas.

Sección de preguntas frecuentes