¿Qué es una infraestructura backend?
Elegir la infraestructura de backend adecuada es crucial al diseñar el backend. Puede afectar el rendimiento, la flexibilidad y la capacidad de mantenimiento del backend, por nombrar solo algunos.
En este artículo, explicaremos qué es la infraestructura de backend, exploraremos diferentes tipos de infraestructuras de backend y analizaremos los factores esenciales que debe recordar al tomar una decisión.
Además, veremos cómo crear una infraestructura de backend usando Back4app.
Contents
Objetivos
Al finalizar este artículo, usted podrá:
- Explicar qué es la infraestructura backend
- Analizar los diferentes tipos de infraestructuras de backend (incluidas IaaS, PaaS y BaaS)
- Elegir la infraestructura de backend adecuada para su proyecto
- Crear su propio backend con Back4app
¿Qué es una infraestructura backend?
La infraestructura de backend es la combinación de componentes de software y hardware que respaldan un sistema de backend. Esto incluye servidores, contenedores, componentes de red, firewall y otros recursos.
La infraestructura de backend es responsable de la alta disponibilidad, el escalamiento, el equilibrio de carga, la seguridad, el enrutamiento, etc.
La infraestructura de backend debe diseñarse de tal manera que ofrezca una experiencia de usuario fluida.
¿Qué tener en cuenta al elegir una infraestructura backend?
Analicemos los factores esenciales a tener en cuenta al elegir una infraestructura de backend.
Velocidad
La velocidad es una de las características fundamentales de la infraestructura de backend. Los usuarios quieren que la aplicación funcione de la forma más fluida posible. Por eso, es necesario optimizar la comunicación entre el cliente y el backend.
Para mitigar la percepción de retrasos en la comunicación, puede usar algunos trucos ingeniosos. Por ejemplo, puede implementar pantallas de esqueleto, barras de carga y mostrar consejos y trucos en la interfaz de usuario.
La velocidad también es uno de los factores más críticos en el SEO.
Flexibilidad
La flexibilidad se refiere a qué lenguajes de programación, marcos y otras tecnologías (por ejemplo, bases de datos) admite su infraestructura de backend.
Al elegir una infraestructura de backend, asegúrese de elegir algo que admita una variedad de tecnologías.
Escalabilidad
Debe tener en cuenta la escalabilidad desde el momento en que comience a crear su aplicación. Piense en cómo se utilizará su aplicación. ¿Tendrá una cantidad constante de usuarios o habrá picos de usuarios en ocasiones?
La infraestructura de backend debe estar diseñada de tal manera que admita cargas de trabajo extremas.
Para minimizar los gastos del servidor, las instancias de la aplicación deben crearse y destruirse sobre la marcha.
Mantenibilidad
Desarrollar y publicar su aplicación es solo el 80 % del trabajo. Después de eso, tendrá que invertir mucho tiempo en mantenerla. Actualizar el software de su servidor e implementar parches de seguridad debería ser lo más fácil posible.
Opte por una infraestructura de backend con un sistema CI/CD integrado o implemente el suyo propio.
Requisitos de DevOps
Algunos tipos de infraestructuras de backend son más difíciles de usar. Elija la infraestructura de backend que pueda gestionar con tiempo y recursos.
Si decide utilizar una infraestructura de backend de nivel inferior, como IaaS, necesitará un equipo de DevOps especializado para gestionarla.
Seguridad
Usted es totalmente responsable de mantener seguros los datos de sus usuarios. Con un número cada vez mayor de ciberataques, debe asegurarse de que su infraestructura de backend cumpla con los últimos estándares de seguridad.
Utilice contraseñas seguras generadas automáticamente, configure el firewall, no ejecute software no confiable en sus servidores, realice controles de seguridad regulares, etc.
Tipos de infraestructura de backend
Puede utilizar sus servidores (la llamada infraestructura tradicional) o aprovechar la infraestructura en la nube para implementar su backend.
En la última década, muchas empresas han optado por modelos de nube porque les permite ahorrar tiempo y dinero.
Analicemos algunos de los más populares.
Infraestructura como servicio o IaaS
La infraestructura como servicio (IaaS) es el modelo de computación en la nube menos abstracto.
En este modelo, el proveedor de la nube proporciona recursos informáticos en un entorno virtualizado, como servidores, almacenamiento, sistemas operativos y componentes de red.
La infraestructura como servicio (IaaS) existe desde 2010 y sigue siendo el modelo de computación en la nube más popular.
Entre sus ventajas se encuentran la gran escalabilidad, el control de alto nivel y la eficiencia de precios.
Por el contrario, sus desventajas son la gestión compleja y los costes de mantenimiento más elevados que otros modelos de nube.
Algunos de los proveedores de IaaS más populares son:
Plataforma como servicio o PaaS
La plataforma como servicio (PaaS) es un modelo de computación en la nube que ofrece un entorno de desarrollo, gestión y distribución de aplicaciones fácil de usar.
Incluye varias herramientas de desarrollo de aplicaciones integradas, lo que facilita la puesta en funcionamiento de su aplicación.
PaaS agiliza la gestión de la infraestructura, lo que permite un acceso más rápido al mercado, mayor seguridad, ahorro de costes, escalabilidad, alta disponibilidad y menor codificación.
Por otro lado, puede vincularlo a las capacidades del proveedor, plantear riesgos de dependencia del proveedor y limitar la flexibilidad y el control.
Algunos ejemplos de soluciones PaaS incluyen:
Backend como servicio o BaaS
Backend as a Service (BaaS) automatiza el desarrollo del lado del servidor y la gestión de la infraestructura en la nube.
Ofrece bases de datos en tiempo real, gestión de usuarios, autenticación, notificaciones, integraciones con redes sociales, etc.
BaaS libera a los desarrolladores de las preocupaciones del backend, lo que les permite centrarse en el frontend y el negocio principal.
BaaS combina los beneficios de IaaS y PaaS con la abstracción del backend, lo que da como resultado un tiempo de comercialización más rápido y ahorros de costos.
Las desventajas son la falta de control, el riesgo de dependencia de un proveedor y un costo relativamente alto.
Mis plataformas BaaS favoritas personales son:
Contenedores como servicio o CaaS
Los contenedores como servicio (CaaS) son un modelo de computación en la nube para cargar, crear, escalar y administrar contenedores.
Por lo general, CaaS incluye un entorno de ejecución de contenedores, un registro de contenedores, una funcionalidad de escalado automático, un sistema de CI/CD integrado, equilibrio de carga y mucho más.
CaaS simplifica el manejo de contenedores y elimina las preocupaciones sobre la infraestructura subyacente.
Fomenta el desarrollo ágil, facilita la arquitectura de microservicios y acelera la creación de aplicaciones altamente escalables.
Las plataformas CaaS incluyen:
¿Cómo crear una infraestructura backend?
En esta parte del artículo, crearemos una infraestructura de backend usando Back4app.
¿Cómo crear una infraestructura backend?
En esta parte del artículo, crearemos una infraestructura de backend usando Back4app.
¿Qué es Back4app?
Back4app es una plataforma Backend as a Service (BaaS) excepcional que le permite crear backends para aplicaciones web y móviles rápidamente.
La plataforma está construida con tecnologías de código abierto y tiene muchas funciones, como bases de datos similares a hojas de cálculo, almacenamiento de archivos, gestión de usuarios, autenticación, API generadas automáticamente, notificaciones y mucho más.
Back4app puede ayudarle a acelerar significativamente su tiempo de comercialización. Al aprovecharlo, puede centrarse en el núcleo de su negocio en lugar de preocuparse por el backend o la infraestructura subyacente.
No necesitará ingenieros de DevOps especializados y sus costos de mantenimiento serán menores.
Lo mejor de Back4app es que viene con un nivel gratuito. El nivel gratuito es excelente para probar la plataforma o alojar proyectos personales. Si su aplicación tiene éxito, puede actualizar a niveles premium.
Para obtener más información sobre Back4app, consulte ¿Qué es Back4app?
Descripción general del proyecto
Para demostrar cómo crear un backend, crearemos un servicio backend de comercio electrónico simple. El backend nos permitirá administrar productos, categorías y pedidos.
El diagrama ER de nuestro proyecto se verá así:
Crearemos el backend con una cantidad mínima de código y demostraremos cómo se puede usar en el lado del cliente (a través de SDK, API REST y API GraphQL).
Crear aplicación
Para seguir, se requiere una cuenta de Back4app. ¿Necesita una? ¡Regístrese hoy mismo!
Después de iniciar sesión en su cuenta de Back4app, verá la lista de sus aplicaciones. Haga clic en el botón “Crear aplicación” para comenzar el proceso de creación de la aplicación.
A continuación, seleccione “BaaS” porque estamos configurando un backend.
Elija un nombre para la aplicación, elija “NoSQL” y cree la aplicación.
Back4app tardará un tiempo en configurar todo. Se encargará de la capa de aplicación, la base de datos, las copias de seguridad, el escalado y más.
Una vez creada la aplicación, se le dirigirá a la base de datos en tiempo real de su aplicación.
Configurar la base de datos
Ahora que hemos creado nuestra aplicación, ocupémonos de la base de datos.
Primero tenemos que crear una clase para almacenar datos en la base de datos. Puede considerar las clases como tablas (terminología SQL) o modelos (terminología ORM). Cada clase tiene los siguientes cuatro campos de forma predeterminada:
+-------------+-------------+------------------------------------------+
| Tipo | Nombre | Descripción |
+-------------+-------------+------------------------------------------+
| String | objectId | Identificador único del objeto |
+-------------+-------------+------------------------------------------+
| Date | updatedAt | Fecha y hora de la última actualización |
+-------------+-------------+------------------------------------------+
| Date | createdAt | Fecha y hora de creación |
+-------------+-------------+------------------------------------------+
| ACL | ACL | Lista de control de acceso |
+-------------+-------------+------------------------------------------+Como se mencionó en la descripción general del proyecto, nuestro proyecto tendrá tres clases. Cree la primera haciendo clic en el botón “Crear clase” en la barra lateral. Nómbrela ProductCategory:
Añada los siguientes campos:
+-----------------------------------------------------------------------
| Tipo | Nombre | Valor | Obligatorio |
+-------------------------------------------+---------------+----------+
| String | name | <leave blank> | sí |
+-------------------------------------------+---------------+----------+
| String | description | <leave blank> | no |
+----------------------------------------------------------------------+Realice los mismos pasos para la clase Product (Producto):
+-------------------------------------------------------------------------
| Tipo | Nombre | Valor |Obligatorio |
+-----------------------------+-------------------------------------------
| String | name | <leave blank> | sí |
+-----------------------------+-------------------------------------------
| String | description | <leave blank> | no |
+-------------------------------------------------------------------------
| Relation -> ProductCategory | categories | <leave blank> | no |
+-----------------------------+-------------+---------------+-------------
| Number | price | 0 | yes |
+-----------------------------+-------------+---------------+------------Utilizamos el tipo de datos Relación para manejar la relación de muchos a muchos.
Por último, cree la clase Order (Orden):
+----------------------------------------------------------------------
| Tipo de datos | Nombre | Valor | Obligatorio|
+-----------------------------+------------+---------------+----------+
| Pointer -> Product | product | <leave blank> | sí |
+-----------------------------+------------+---------------+----------+
| String | cFirstName | <leave blank> | sí |
+-----------------------------+------------+---------------+----------+
| String | cLastName | <leave blank> | sí |
+-----------------------------+------------+---------------+----------+
| String | cAddress | <leave blank> | sí |
+-----------------------------+------------+---------------+----------+
| Number | delivered | false | sí |
+-----------------------------+------------+---------------+----------+Utilizamos el tipo de datos Pointer para manejar la relación de uno a muchos.
Una vez que haya terminado, debería ver las clases en la barra lateral.
Rellenar la base de datos
Continuando, vamos a llenar la base de datos.
Comience por crear algunas categorías de productos, productos y pedidos (en este orden). Si no se le ocurren ideas, no dude en importar este elemento.
Para importar un archivo JSON, utilice la opción “Más opciones > Importar > Datos de clase > Seleccionar archivo”. Asegúrese de importar los archivos JSON en el siguiente orden:
- ProductCategory.json
- Product.json
- _Join꞉categories꞉Product.json
- Order.json
Una vez que haya terminado, debería tener algunos productos, categorías y pedidos en su base de datos. Este paso es necesario porque necesitaremos algunos datos para probar el backend en la fase posterior.
Proteger la base de datos
De forma predeterminada, las clases de base de datos se crean en “modo protegido”. Mientras se está en modo protegido, la única forma de interactuar y administrar objetos es mediante la clave maestra.
Esto no es óptimo porque no podemos obtener ni administrar objetos desde el lado del cliente.
Para poder hacer eso, tenemos que relajar algunas restricciones. Back4app/Parse viene con dos mecanismos de restricción:
- Permisos a nivel de clase (CLP)
- Permisos de nivel de acceso (ACL)
Las CLP nos permiten aplicar restricciones a nivel de clase, mientras que las ACL nos permiten aplicar restricciones a nivel de objeto.
Ambos mecanismos pueden restringir una clase u objeto a un rol o usuario específico.
Seleccione la clase de producto en la barra lateral y haga clic en el texto “Protegido” en la parte superior de la pantalla. Luego modifique los CLP:
Realice los mismos pasos para el modelo ProductCategory.
A continuación, actualice los CLP para la clase Order:
Preste atención a la imagen. Aquí también habilitamos el permiso de creación.
Los nuevos CLP permitirán a los usuarios no autenticados obtener, consultar y contar productos y categorías de productos, pero no modificarlos. Lo mismo se aplica a la clase Pedido, pero aquí los usuarios también pueden crear nuevos pedidos.
Para obtener más información, consulte nuestro artículo sobre seguridad del servidor Parse.
Admin App
En este momento, la única forma de administrar objetos en su base de datos es mediante la vista de base de datos.
Si bien eso funciona para los desarrolladores, no es intuitivo para los usuarios no técnicos. Además, les da a los usuarios demasiado control y es propenso a errores humanos.
Afortunadamente, Back4app te permite habilitar fácilmente la función “Aplicación de administración”. La aplicación de administración es un panel de administración fácil de usar y adaptado a las clases de su base de datos.
Habilítelo navegando primero a “More > Admin App” en la barra lateral. Luego haga clic en “Habilitar”:
Back4app le pedirá que elija un nombre de usuario, una contraseña y un subdominio. Yo he decidido utilizar lo siguiente:
user: root
pass: complexpassword123
subdomain: https://binfra.admin.back4app.com/Genial, eso es todo lo que tiene que hacer.
Puede acceder al panel de administración haciendo clic en “URL de la aplicación de administración”. Al hacer clic en ella, se abrirá una nueva ventana del navegador y se le solicitará que ingrese sus credenciales de administrador. Una vez que haya iniciado sesión, puede crear, actualizar y eliminar objetos.
Intente jugar con el tablero para acostumbrarse.
Cloud Code
Back4app le permite ejecutar código JavaScript personalizado a través del llamado Cloud Code. Con Cloud Code, puede definir funciones que se pueden activar mediante Parse, solicitudes HTTP o ejecutarse periódicamente. Además, Cloud Code se puede utilizar para crear aplicaciones web mediante Express.
Cloud Code Function
Supongamos que queremos una función de Cloud Code que calcule las ventas actuales.
En primer lugar, dirígete a “Cloud Code > Función y alojamiento web” en la barra lateral. Observará que la vista de Cloud Code está dividida en dos partes.
En el lado izquierdo, puede ver la estructura del directorio y el código en el lado derecho.
A continuación, abra cloud/main.js y pegue el siguiente código:
// cloud/main.js
Parse.Cloud.define("calculateSales", async (request) => {
const orderClass = Parse.Object.extend("Order");
const orderQuery = new Parse.Query(orderClass);
let sales = 0;
try {
const orders = await orderQuery.find();
for (var i = 0; i < orders.length; i++) {
let order = orders[i];
let productId = order.get("product")["id"];
const productClass = Parse.Object.extend("Product");
const productQuery = new Parse.Query(productClass);
const product = await productQuery.get(productId);
sales += product.get("price");
}
return {
sales: sales,
};
} catch (error) {
console.error("Error calculating the sales: " + error.message);
return {
sales: 0,
}
}
});
Parse.Cloud.job("printSales", async (request, status) => {
try {
const result = await Parse.Cloud.run("calculateSales");
console.log("Sales: " + result.sales + "$");
} catch (error) {
console.error("Error calculating the sales: " + error.message);
}
});- Definimos una función de Cloud Code llamada calculateSales(). La función recorre todos los pedidos, recupera los productos correspondientes y suma sus precios.
- Definimos un trabajo de Cloud Code llamado printSales(), que nos permite ejecutar la función desde el panel de Parse y programarla periódicamente.
Por último, haga clic en “Implementar” para implementar el código de nube.
Asegúrese de que el trabajo funciona navegando a “Cloud Code > Trabajos” en la barra lateral y luego ejecutando el trabajo printSales(). Si todo funciona bien, deberías ver un mensaje que diga, por ejemplo, Sales: 1440$ al revisar los registros.
Programación de Cloud Code
Para programar el trabajo, debe navegar a “Configuración de la aplicación > Configuración del servidor” en la barra lateral. Desplácese hacia abajo hasta “Trabajos en segundo plano”, haga clic en “Programar un trabajo” y complete el formulario.
Para asegurarse de que funciona, revise los registros una vez más.
Lado del cliente
Hay varias formas de interactuar con su backend basado en Back4app:
- Parse SDK
- API RESTful (generada automáticamente)
- API GraphQL (generada automáticamente)
Como regla general, siempre debe usar Parse SDK si está disponible para su plataforma. Si no, opte por la API RESTful o la API GraphQL. La elección entre las API depende de sus datos.
Aprenda a utilizar Parse SDK con varios marcos consultando la documentación.
Sin embargo, probemos nuestro backend usando la consola REST incorporada.
Vaya a “API > REST” en la barra lateral e intente consultar todos los productos completando el formulario:
Debería obtener una respuesta similar:
{
"results": [
{
"objectId": "4ZyHH3X0RQ",
"name": "Fitness Tracker Watch",
"description": "...",
"price": 80,
"createdAt": "2023-10-17T20:03:55.424Z",
"updatedAt": "2023-10-17T20:24:12.322Z",
"categories": {
"__type": "Relation",
"className": "ProductCategory"
}
},
{
"objectId": "cDqlGJzT5U",
"name": "Organic Fruit Basket",
"description": "...",
"price": 40,
"createdAt": "2023-10-17T20:04:10.063Z",
"updatedAt": "2023-10-17T20:24:00.382Z",
"categories": {
"__type": "Relation",
"className": "ProductCategory"
}
},
// ...
}Intente realizar las siguientes consultas:
- Obtener todos los productos que sean más caros que 50
- Obtener todos los pedidos que aún no se han entregado
- Crear un nuevo producto y agrégale una categoría
- Eliminar un pedido
Conclusión
En conclusión, ahora sabe qué es la infraestructura de backend, está familiarizado con varios tipos de infraestructuras de backend y sabe cómo elegir la infraestructura adecuada para su proyecto.
Además de eso, aprendió a crear una infraestructura de backend en Back4app. Se encargó de la base de datos, la seguridad de la base de datos, el código personalizado, la programación de trabajos y las pruebas de API.
Para obtener orientación sobre la creación del lado del cliente para un backend basado en Back4app, explora nuestros otros artículos:
- ¿Cómo alojar frontend y backend?
- ¿Cómo desarrollar una aplicación de redes sociales?
- ¿Cómo construir un chatbot usando React?
Los recursos de artículos adicionales están disponibles en código abierto en un repositorio de GitHub.
