Quickstarters
¿Cómo construir un backend para Elixir?

40min
Introducción
En este tutorial, aprenderás cómo construir un backend para Elixir 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. 
Elixir, que se ejecuta en la máquina virtual Erlang (BEAM) y aprovecha OTP (Erlang OTP), es conocido por su entorno tolerante a fallos y concurrente, que se combina bien con Back4App para formar una infraestructura moderna y de alto rendimiento.
Verás cómo la configuración rápida de Back4App y su entorno intuitivo pueden reducir drásticamente tu tiempo y esfuerzo en comparación con la configuración manual de servidores y bases de datos. 
Esto incluye aprovechar el patrón de coincidencia, además de conectarse al marco web de elección de Elixir. 
Al final de este tutorial, tendrás una base sólida que podrás extender a una aplicación lista para producción o mejorar con lógica personalizada y APIs de terceros.
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 de desarrollo básico de Elixir
 Asegúrate de tener Elixir instalado en tu máquina. Si planeas usar un marco web como Phoenix, consulta la guía de instalación de Phoenix como referencia.
Familiaridad con los conceptos de Elixir
 Documentación oficial de Elixir.
Si eres nuevo en Elixir, revisa estos recursos o un tutorial para principiantes antes de comenzar.
Asegúrate de tener todos estos requisitos previos en su lugar antes de comenzar. Tener tu proyecto de Back4App configurado y tu entorno local de Elixir listo te ayudará a seguir más fácilmente.
Paso 1 – Crear un nuevo proyecto en Back4App y conectarse
Crear un nuevo proyecto
El primer paso en cómo construir un backend para Elixir 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 Back4App.
Dale un nombre a tu app (por ejemplo, “Elixir-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 discutidas en este tutorial.
Conectando a través de REST o GraphQL
Back4App utiliza la plataforma Parse como base. Para Elixir, no hay un SDK oficial de Parse en este momento. En su lugar, puedes conectarte fácilmente a Back4App utilizando las APIs REST o GraphQL. En tu proyecto de Elixir, deberás:
Recupera tu ID de Aplicación y Claves REST o GraphQL desde la sección “Configuración de la App” o “Seguridad y Claves” en el panel de control de Back4App.
Configura las solicitudes HTTP utilizando una biblioteca de Elixir como HTTPoison o Tesla.
Por ejemplo, para almacenar credenciales en un archivo de configuración (config/dev.exs o similar):
Text
config :my_app, :b4a,
  app_id: "YOUR_APPLICATION_ID",
  rest_key: "YOUR_REST_API_KEY",
  server_url: "https://parseapi.back4app.com"
config :my_app, :b4a,
  app_id: "YOUR_APPLICATION_ID",
  rest_key: "YOUR_REST_API_KEY",
  server_url: "https://parseapi.back4app.com"
﻿
Luego puedes hacer referencia a estas credenciales en tu código para realizar llamadas REST. A lo largo de esta guía, mostraremos cómo interactuar con la base de datos de Back4App, el sistema de usuarios y otras características utilizando solicitudes HTTP o GraphQL estándar.
Paso 2 – Configurando la Base de Datos
Creando un modelo de datos
En Back4App, los datos se almacenan en clases. Puedes crear una nueva clase en el panel de control de Back4App:
Navega a la sección “Base de datos” en tu panel de control de Back4App.
Crea una nueva clase (por ejemplo, “Todo”) y añade columnas relevantes, como título (String) y estáCompleto (Boolean).
Crear nueva clase
﻿
Creando un modelo de datos utilizando el Agente de IA
Back4App también proporciona un Agente de IA para ayudarte a describir y crear tu modelo de datos:
Abre el Agente de IA desde tu panel de control de la aplicación o el menú.
Describe tu modelo de datos en lenguaje sencillo (por ejemplo, “Por favor, crea una nueva aplicación Todo con un esquema de clase completo.”).
Deja que el Agente de IA cree el esquema automáticamente.
﻿
Lectura y escritura de datos usando SDK (si corresponde)
Dado que Elixir no tiene un SDK de Parse oficial, omitiremos el uso directo del SDK. En su lugar, mostraremos REST, GraphQL, y Consultas en vivo enfoques a continuación.
Lectura y escritura de datos usando REST API
Instala un cliente HTTP como HTTPoison en tu mix.exs:
Text
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
﻿
Luego, ejecuta mix deps.get.
Para crear (guardar) un objeto Todo desde tu aplicación Elixir:
Text
defmodule MyApp.Todo do
  @moduledoc false
  require Logger
  alias MyApp.Config

  def create_todo(title, is_completed) do
    url      = Config.server_url() <> "/classes/Todo"
    headers  = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body     = Jason.encode!(%{"title" => title, "isCompleted" => is_completed})

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("Todo created: #{resp_body}")
        {:ok, resp_body}

      {:ok, %HTTPoison.Response{status_code: status, body: error_body}} ->
        Logger.error("Error creating todo (#{status}): #{error_body}")
        {:error, error_body}

      {:error, error} ->
        Logger.error("HTTP error: #{inspect(error)}")
        {:error, error}
    end
  end
end
defmodule MyApp.Todo do
  @moduledoc false
  require Logger
  alias MyApp.Config

  def create_todo(title, is_completed) do
    url      = Config.server_url() <> "/classes/Todo"
    headers  = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body     = Jason.encode!(%{"title" => title, "isCompleted" => is_completed})

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("Todo created: #{resp_body}")
        {:ok, resp_body}

      {:ok, %HTTPoison.Response{status_code: status, body: error_body}} ->
        Logger.error("Error creating todo (#{status}): #{error_body}")
        {:error, error_body}

      {:error, error} ->
        Logger.error("HTTP error: #{inspect(error)}")
        {:error, error}
    end
  end
end
﻿
Y para consultar tus objetos Todo:
Text
def fetch_todos() do
  url     = Config.server_url() <> "/classes/Todo"
  headers = [
    {"X-Parse-Application-Id", Config.app_id()},
    {"X-Parse-REST-API-Key", Config.rest_key()}
  ]

  HTTPoison.get(url, headers)
end
def fetch_todos() do
  url     = Config.server_url() <> "/classes/Todo"
  headers = [
    {"X-Parse-Application-Id", Config.app_id()},
    {"X-Parse-REST-API-Key", Config.rest_key()}
  ]

  HTTPoison.get(url, headers)
end
﻿
Lectura y Escritura de Datos usando la API de GraphQL
También puedes interactuar a través de GraphQL. Por ejemplo, creando un Todo:
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
    }
  }
}
﻿
En Elixir, también podrías enviar esto con un cliente HTTP:
Text
graph_query = """
mutation {
  createTodo(input: {
    fields: {
      title: "New from GraphQL",
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
    }
  }
}
"""

url = Config.server_url() <> "/graphql"
headers = [
  {"X-Parse-Application-Id", Config.app_id()},
  {"X-Parse-REST-API-Key", Config.rest_key()},
  {"Content-Type", "application/json"}
]

HTTPoison.post(url, Jason.encode!(%{"query" => graph_query}), headers)
graph_query = """
mutation {
  createTodo(input: {
    fields: {
      title: "New from GraphQL",
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
    }
  }
}
"""

url = Config.server_url() <> "/graphql"
headers = [
  {"X-Parse-Application-Id", Config.app_id()},
  {"X-Parse-REST-API-Key", Config.rest_key()},
  {"Content-Type", "application/json"}
]

HTTPoison.post(url, Jason.encode!(%{"query" => graph_query}), headers)
﻿
Trabajando con Consultas en Vivo (Opcional)
Para actualizaciones en tiempo real, Back4App ofrece Consultas en Vivo. Puedes habilitar Consultas en Vivo en la Configuración del Servidor. Dado que no hay una biblioteca de cliente Parse nativa para Elixir en este momento, normalmente te conectarías a través de un canal de Phoenix o cualquier cliente WebSocket personalizado al wss://YOUR_SUBDOMAIN_HERE.b4a.io punto final. Esto puede ser más avanzado, requiriendo codificación personalizada para manejar suscripciones, mensajes, etc.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Resumen Breve
Back4App ofrece Listas de Control de Acceso (ACLs) y Permisos a Nivel de Clase (CLPs) para proteger y gestionar el acceso a los datos. Las ACLs se aplican a objetos individuales, mientras que los CLPs se aplican a toda la clase.
﻿
Paso a Paso
Permisos a Nivel de Clase (CLPs): En tu panel de Back4App, bajo Base de Datos, selecciona una clase (por ejemplo, “Todo”) y abre la pestaña de Permisos a Nivel de Clase. Ajusta la configuración (por ejemplo, “Requiere Autenticación” o “Sin Acceso” para el público).
Configurar ACLs: Al crear o actualizar un objeto, puedes enviar datos de ACL en tu solicitud REST o GraphQL. Por ejemplo, especifica el _ACL campo en JSON si necesitas un control detallado por objeto.
Editar ACL
﻿
Para más información, visita las Directrices de Seguridad de la Aplicación.
Paso 4 – Escribiendo Funciones de Cloud Code
Por qué Cloud Code
Cloud Code te permite ejecutar lógica del lado del servidor sin gestionar tus propios servidores. Con Elixir, normalmente confías en OTP para la concurrencia, pero aquí puedes simplemente crear Cloud Code en JavaScript en Back4App para manejar validaciones, disparadores o lógica de negocio personalizada. Este código se ejecuta en Parse Server, por lo que puedes mantener tu código de Elixir enfocado en tareas de cliente o microservicio mientras el trabajo pesado ocurre en Cloud Code.
Función de Ejemplo
En tu main.js en el panel de Back4App o usando la CLI:
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 };
});
﻿
Despliegue
Despliega a través de la Back4app CLI o pegando en el panel bajo Cloud Code > Functions y haciendo clic en Deploy.
﻿
Llamando a Cloud Code
Desde Elixir, podrías usar:
Text
defmodule MyApp.CloudFunctions do
  alias MyApp.Config

  def calculate_text_length(text) do
    url = Config.server_url() <> "/functions/calculateTextLength"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{text: text})

    HTTPoison.post(url, body, headers)
  end
end
defmodule MyApp.CloudFunctions do
  alias MyApp.Config

  def calculate_text_length(text) do
    url = Config.server_url() <> "/functions/calculateTextLength"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{text: text})

    HTTPoison.post(url, body, headers)
  end
end
﻿
Paso 5 – Configuración de la Autenticación
Habilitar o Configurar la Autenticación
Back4App utiliza la clase User para la autenticación. Puedes gestionar el registro, inicio de sesión y restablecimiento de contraseñas fácilmente. Desde Elixir, normalmente usarás llamadas REST:
Text
defmodule MyApp.Auth do
  alias MyApp.Config

  def sign_up_user(username, password, email) do
    url = Config.server_url() <> "/users"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{
      username: username,
      password: password,
      email: email
    })

    HTTPoison.post(url, body, headers)
  end

  def log_in_user(username, password) do
    url = Config.server_url() <> "/login?username=#{username}&password=#{password}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()}
    ]

    HTTPoison.get(url, headers)
  end
end
defmodule MyApp.Auth do
  alias MyApp.Config

  def sign_up_user(username, password, email) do
    url = Config.server_url() <> "/users"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{
      username: username,
      password: password,
      email: email
    })

    HTTPoison.post(url, body, headers)
  end

  def log_in_user(username, password) do
    url = Config.server_url() <> "/login?username=#{username}&password=#{password}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()}
    ]

    HTTPoison.get(url, headers)
  end
end
﻿
Inicio de Sesión Social
Back4App soporta la integración con Google, Apple, Facebook y más. En la mayoría de los casos, dirigirás a los usuarios al flujo de OAuth, luego usarás los tokens devueltos por estos proveedores para completar el inicio de sesión en Parse. Consulta Documentación de Inicio de Sesión Social para más detalles.
Paso 6 – Manejo del Almacenamiento de Archivos
Configuración del Almacenamiento de Archivos
Back4App almacena archivos de forma segura. Desde Elixir, puedes subir archivos a través de REST:
Text
defmodule MyApp.FileStorage do
  alias MyApp.Config
  require Logger

  def upload_file(file_path) do
    file_name = Path.basename(file_path)
    url = Config.server_url() <> "/files/#{file_name}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/octet-stream"}
    ]
    body = File.read!(file_path)

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("File uploaded: #{resp_body}")
        {:ok, resp_body}
      error ->
        Logger.error("Error uploading file: #{inspect(error)}")
        error
    end
  end
end
defmodule MyApp.FileStorage do
  alias MyApp.Config
  require Logger

  def upload_file(file_path) do
    file_name = Path.basename(file_path)
    url = Config.server_url() <> "/files/#{file_name}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/octet-stream"}
    ]
    body = File.read!(file_path)

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("File uploaded: #{resp_body}")
        {:ok, resp_body}
      error ->
        Logger.error("Error uploading file: #{inspect(error)}")
        error
    end
  end
end
﻿
Recibirás una respuesta JSON con la URL del archivo, que puedes almacenar en una clase (por ejemplo, Foto) para referencia.
Consideraciones de Seguridad
Puedes configurar quién puede subir archivos en fileUpload configuraciones en tu proyecto de Back4App, restringiendo las subidas a usuarios autenticados si lo deseas.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Descripción General
La verificación de correo electrónico asegura que los usuarios posean la dirección de correo electrónico utilizada durante el registro. El restablecimiento de contraseña les permite recuperar cuentas de manera segura. Ambas funciones están integradas en Back4App.
Configuración del Panel de Control de Back4App
Habilitar la verificación de correo electrónico en la “Configuración de la aplicación” o “Autenticación” de su aplicación.
Configurar el Dirección de envío y las plantillas de correo electrónico.
Habilitar el restablecimiento de contraseña para permitir que los usuarios restablezcan a través de un enlace enviado por correo electrónico.
Código/Implementación
Una vez habilitado en el panel de control, puede activar los restablecimientos de contraseña:
Text
defmodule MyApp.Auth do
  def request_password_reset(email) do
    url = Config.server_url() <> "/requestPasswordReset"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{email: email})

    HTTPoison.post(url, body, headers)
  end
end
defmodule MyApp.Auth do
  def request_password_reset(email) do
    url = Config.server_url() <> "/requestPasswordReset"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{email: email})

    HTTPoison.post(url, body, headers)
  end
end
﻿
Paso 8 – Programación de Tareas con Trabajos en la Nube
Qué Hacen los Trabajos en la Nube
Los trabajos en la nube te permiten automatizar tareas rutinarias como limpiar datos antiguos o enviar correos electrónicos periódicos. Los escribes en Cloud Code.
Ejemplo
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);

  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);
  }
});
// 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);
  }
});
﻿
Desplegar el código.
Ir al Panel de Control de Back4app > Configuraciones de la Aplicación > Configuraciones del Servidor > Trabajos en Segundo Plano.
Programar el trabajo para que se ejecute diariamente o con la frecuencia que elijas.
Programación de un Trabajo en la Nube
﻿
Paso 9 – Integrando Webhooks
Definición
Los webhooks permiten que tu aplicación Back4App envíe solicitudes HTTP a un servicio externo (por ejemplo, un canal de Slack o Stripe) cuando ocurren ciertos eventos.
Configuración
Navega a la configuración de Webhooks en tu panel de Back4App > Más > Webhooks.
Establece el endpoint (por ejemplo, https://your-service.com/webhook-endpoint).
Configura los triggers como “Nuevo registro en la clase Todo.”
Añadiendo un Webhook
﻿
Ejemplo
Si deseas enviar datos a Slack cada vez que se crea un Todo, puedes agregar un nuevo webhook apuntando a la URL de tu webhook entrante de Slack. También puedes definir Webhooks en Cloud Code enviando solicitudes HTTP personalizadas en triggers como afterSave.
WebHook BeforeSave
﻿
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 para gestionar tus datos. Puedes habilitarla desde Panel de la Aplicación > Más > Aplicación de Administración.
Habilitar Aplicación de Administración
﻿
Características
Crear un Primer Usuario Administrador, que configura el rol de B4aAdminUser y clases adicionales.
Asignar un Subdominio para acceder a la interfaz de administración.
Iniciar sesión para ver y gestionar datos en una interfaz simple.
﻿
Conclusión
Al seguir este tutorial sobre cómo construir un backend para Elixir con Back4App, has:
Creado un backend seguro en la plataforma de Back4App utilizando Elixir para la integración.
Configurado una base de datos con clases, tipos de datos y relaciones.
Usado REST/GraphQL para interactuar con tus datos desde Elixir.
Aplicado seguridad utilizando ACLs y CLPs.
Añadido lógica personalizada con funciones de Cloud Code.
Configurado la autenticación de usuarios con verificación de correo electrónico y restablecimiento de contraseñas.
Manejado el almacenamiento y recuperación de archivos.
Programado trabajos en segundo plano para automatización.
Integrado servicios externos con webhooks.
Explorado el Panel de Administración de Back4App para una fácil gestión de datos.
Con el modelo de concurrencia de Elixir (impulsado por la máquina virtual Erlang) y OTP, combinado con los servicios escalables y flexibles de Back4App, puedes construir backends altamente robustos.
Continúa explorando características más avanzadas, integra tu lógica de negocio y deja que Back4App te ayude a manejar el trabajo pesado.
Próximos Pasos
Construir una aplicación Elixir lista para producción combinando este backend con tu marco web Elixir/Phoenix preferido.
Integrar características avanzadas como control de acceso basado en roles o APIs de terceros (pasarelas de pago, servicios de mensajería).
Explorar la documentación oficial de Back4app para seguridad avanzada, registros, ajuste de rendimiento y más.
Revisar otros tutoriales para aplicaciones en tiempo real, paneles de IoT o servicios basados en ubicación. Con la coincidencia de patrones y la concurrencia de OTP a tu disposición, ¡estás equipado para abordar una amplia gama de aplicaciones!
﻿
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Ruby?
¿Cómo construir un backend para Play Framework?