Schnellstarter
Wie man ein Backend für Elixir erstellt?

40min
Einführung
In diesem Tutorial lernen Sie wie man ein Backend für Elixir mit Back4App erstellt. 
Wir werden die Integration wesentlicher Back4App-Funktionen durchgehen – wie Datenbankverwaltung, Cloud-Code-Funktionen, REST- und GraphQL-APIs, Benutzerauthentifizierung und Echtzeitanfragen (Live Queries) – um ein sicheres, skalierbares und robustes Backend zu erstellen. 
Elixir, das auf der Erlang-VM (BEAM) läuft und OTP (Erlang OTP) nutzt, ist bekannt für seine fehlertolerante, nebenläufige Umgebung, die gut mit Back4App harmoniert, um eine moderne, leistungsstarke Infrastruktur zu bilden.
Sie werden sehen, wie die schnelle Einrichtung und die intuitive Umgebung von Back4App Ihre Zeit und Mühe im Vergleich zur manuellen Konfiguration von Servern und Datenbanken drastisch reduzieren können. 
Dies umfasst die Nutzung von Pattern Matching sowie die Anbindung an das bevorzugte Web-Framework von Elixir. 
Am Ende dieses Tutorials haben Sie eine solide Grundlage, die Sie in eine produktionsbereite Anwendung erweitern oder mit benutzerdefinierter Logik und Drittanbieter-APIs verbessern können.
Voraussetzungen
Um dieses Tutorial abzuschließen, benötigen Sie:
Ein Back4App-Konto und ein neues Back4App-Projekt
 Erste Schritte mit Back4app.
Wenn Sie kein Konto haben, können Sie eines kostenlos erstellen. Befolgen Sie die obige Anleitung, um Ihr Projekt vorzubereiten.
Grundlegende Elixir-Entwicklungsumgebung
 Stellen Sie sicher, dass Elixir auf Ihrem Computer installiert ist. Wenn Sie ein Web-Framework wie Phoenix verwenden möchten, siehe die Phoenix-Installationsanleitung zur Referenz.
Vertrautheit mit Elixir-Konzepten
 Offizielle Elixir-Dokumentation.
Wenn Sie neu in Elixir sind, überprüfen Sie diese Ressourcen oder ein Tutorial für Anfänger, bevor Sie beginnen.
Stellen Sie sicher, dass Sie alle diese Voraussetzungen erfüllt haben, bevor Sie beginnen. Ihr Back4App-Projekt eingerichtet und Ihre lokale Elixir-Umgebung bereit zu haben, wird Ihnen helfen, reibungsloser zu folgen.
Schritt 1 – Erstellen eines neuen Projekts auf Back4App und Verbindung
Ein neues Projekt erstellen
Der erste Schritt in wie man ein Backend für Elixir auf Back4App erstellt, besteht darin, ein neues Projekt zu erstellen. Wenn Sie noch keines erstellt haben, befolgen Sie diese Schritte:
Melden Sie sich bei Ihrem Back4app-Konto an.
Klicken Sie auf die Schaltfläche „Neue App“ in Ihrem Back4App-Dashboard.
Geben Sie Ihrer App einen Namen (z. B. „Elixir-Backend-Tutorial“).
﻿
Sobald das Projekt erstellt ist, sehen Sie es in Ihrem Back4App-Dashboard aufgelistet. Dieses Projekt wird die Grundlage für alle Backend-Konfigurationen sein, die in diesem Tutorial besprochen werden.
Verbindung über REST oder GraphQL
Back4App verwendet die Parse-Plattform als Grundlage. Für Elixir gibt es derzeit kein offizielles Parse SDK. Stattdessen können Sie sich einfach über die REST- oder GraphQL-APIs mit Back4App verbinden. In Ihrem Elixir-Projekt werden Sie:
Ihre Anwendungs-ID und REST- oder GraphQL-Schlüssel aus den „App-Einstellungen“ oder dem Abschnitt „Sicherheit & Schlüssel“ im Back4App-Dashboard abrufen.
HTTP-Anfragen mit einer Elixir-Bibliothek wie HTTPoison oder Tesla konfigurieren.
Zum Beispiel, um Anmeldeinformationen in einer Konfigurationsdatei zu speichern (config/dev.exs oder ähnlich):
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"
﻿
Sie können diese Anmeldeinformationen dann in Ihrem Code verwenden, um REST-Anfragen zu stellen. In diesem Leitfaden zeigen wir, wie man mit der Back4App-Datenbank, dem Benutzersystem und anderen Funktionen über standardmäßige HTTP- oder GraphQL-Anfragen interagiert.
Schritt 2 – Datenbank einrichten
Erstellen eines Datenmodells
In Back4App werden Daten in Klassen. Sie können eine neue Klasse im Back4App-Dashboard erstellen:
Navigieren Sie zum Abschnitt “Datenbank” in Ihrem Back4App-Dashboard.
Erstellen Sie eine neue Klasse (z. B. “Todo”) und fügen Sie relevante Spalten hinzu, wie Titel (String) und isCompleted (Boolean).
Neue Klasse erstellen
﻿
Erstellen eines Datenmodells mit dem KI-Agenten
Back4App bietet auch einen KI-Agenten, der Ihnen hilft, Ihr Datenmodell zu beschreiben und zu erstellen:
Öffnen Sie den KI-Agenten von Ihrem App-Dashboard oder dem Menü.
Beschreiben Sie Ihr Datenmodell in einfacher Sprache (z. B. “Bitte erstellen Sie eine neue Todo-App mit einem vollständigen Klassenschema.”).
Lassen Sie den KI-Agenten das Schema automatisch erstellen.
﻿
Daten lesen und schreiben mit SDK (sofern zutreffend)
Da Elixir kein offizielles Parse SDK hat, überspringen wir die direkte SDK-Nutzung. Stattdessen zeigen wir REST, GraphQL, und Live Queries Ansätze unten.
Daten lesen und schreiben mit REST API
Installieren Sie einen HTTP-Client wie HTTPoison in Ihrer mix.exs:
Text
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
﻿
Führen Sie dann mix deps.get aus.
Um ein Todo-Objekt aus Ihrer Elixir-Anwendung zu erstellen (zu speichern):
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
﻿
Und um Ihre Todo-Objekte abzufragen:
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
﻿
Daten lesen und schreiben mit der GraphQL-API
Sie können auch über GraphQL interagieren. Zum Beispiel, um ein Todo zu erstellen:
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
    }
  }
}
﻿
In Elixir könnten Sie dies auch mit einem HTTP-Client senden:
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)
﻿
Arbeiten mit Live-Abfragen (Optional)
Für Echtzeit-Updates bietet Back4App Live-Abfragen. Sie können Live-Abfragen in den Servereinstellungen Ihrer App aktivieren. Da es derzeit keine native Elixir Parse-Client-Bibliothek gibt, würden Sie typischerweise über einen Phoenix-Kanal oder einen benutzerdefinierten WebSocket-Client mit dem bereitgestellten wss://YOUR_SUBDOMAIN_HERE.b4a.io Endpunkt verbinden. Dies kann fortgeschrittener sein und erfordert benutzerdefiniertes Codieren, um Abonnements, Nachrichten usw. zu verwalten.
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
Kurzer Überblick
Back4App bietet Zugriffskontrolllisten (ACLs) und Klassenebene-Berechtigungen (CLPs) an, um den Datenzugriff zu schützen und zu verwalten. ACLs gelten für einzelne Objekte, während CLPs für die gesamte Klasse gelten.
﻿
Schritt-für-Schritt
Klassenebene Berechtigungen (CLPs): In Ihrem Back4App Dashboard, unter Datenbank, wählen Sie eine Klasse (z.B. „Todo“) und öffnen Sie die Klassenebene Berechtigungen Registerkarte. Passen Sie die Einstellungen an (z.B. „Erfordert Authentifizierung“ oder „Kein Zugriff“ für die Öffentlichkeit).
ACLs konfigurieren: Beim Erstellen oder Aktualisieren eines Objekts können Sie ACL-Daten in Ihrer REST- oder GraphQL-Anfrage senden. Geben Sie beispielsweise das _ACL Feld in JSON an, wenn Sie eine feingranulare Kontrolle pro Objekt benötigen.
ACL bearbeiten
﻿
Für weitere Informationen besuchen Sie die App-Sicherheitsrichtlinien.
Schritt 4 – Schreiben von Cloud-Code-Funktionen
Warum Cloud-Code
Cloud-Code ermöglicht es Ihnen, serverseitige Logik auszuführen, ohne Ihre eigenen Server verwalten zu müssen. Mit Elixir verlassen Sie sich normalerweise auf OTP für die Parallelität, aber hier können Sie einfach JavaScript-Cloud-Code in Back4App erstellen, um Validierung, Trigger oder benutzerdefinierte Geschäftslogik zu behandeln. Dieser Code läuft auf dem Parse-Server, sodass Sie Ihren Elixir-Code auf Client- oder Mikrodienstaufgaben konzentrieren können, während die schwere Arbeit im Cloud-Code erfolgt.
Beispiel-Funktion
In Ihrer main.js auf dem Back4App Dashboard oder mit der 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 };
});
﻿
Bereitstellung
Bereitstellen über die Back4app CLI oder indem Sie in das Dashboard unter Cloud Code > Funktionen einfügen und auf Bereitstellen klicken.
﻿
Cloud Code aufrufen
Von Elixir aus könnten Sie verwenden:
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
﻿
Schritt 5 – Authentifizierung konfigurieren
Authentifizierung aktivieren oder einrichten
Back4App verwendet die Parse User-Klasse zur Authentifizierung. Sie können die Registrierung, den Login und das Zurücksetzen des Passworts einfach verwalten. In Elixir verwenden Sie typischerweise REST-Aufrufe:
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
﻿
Soziale Anmeldung
Back4App unterstützt die Integration mit Google, Apple, Facebook und mehr. In den meisten Fällen leiten Sie die Benutzer zum OAuth-Fluss und verwenden dann die von diesen Anbietern zurückgegebenen Tokens, um die Parse-Anmeldung abzuschließen. Siehe Dokumentation zur sozialen Anmeldung für Details.
Schritt 6 – Dateispeicherung verwalten
Einrichtung der Dateispeicherung
Back4App speichert Dateien sicher. Von Elixir aus laden Sie Dateien über REST hoch:
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
﻿
Sie erhalten eine JSON-Antwort mit der Datei-URL, die Sie in einer Klasse (z.B. Foto) zur Referenz speichern können.
Sicherheitsüberlegungen
Sie können konfigurieren, wer Dateien in den fileUpload-Einstellungen Ihres Back4App-Projekts hochladen kann, und die Uploads auf authentifizierte Benutzer beschränken, wenn gewünscht.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Übersicht
Die E-Mail-Verifizierung stellt sicher, dass die Benutzer die E-Mail-Adresse besitzen, die während der Anmeldung verwendet wurde. Die Passwortzurücksetzung ermöglicht es ihnen, Konten sicher wiederherzustellen. Beide Funktionen sind in Back4App integriert.
Back4App Dashboard-Konfiguration
E-Mail-Verifizierung aktivieren unter den „App-Einstellungen“ oder „Authentifizierung“ Ihrer App.
Konfigurieren Sie die Absenderadresse und E-Mail-Vorlagen.
Passwortzurücksetzung aktivieren um Benutzern zu ermöglichen, über einen Link, der ihnen per E-Mail gesendet wird, zurückzusetzen.
Code/Implementierung
Sobald es im Dashboard aktiviert ist, können Sie Passwortzurücksetzungen auslösen:
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
﻿
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Welche Cloud-Jobs gibt es
Cloud-Jobs ermöglichen es Ihnen, Routineaufgaben wie das Bereinigen alter Daten oder das Versenden periodischer E-Mails zu automatisieren. Sie schreiben sie in Cloud Code.
Beispiel
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);
  }
});
﻿
Code bereitstellen.
Gehen Sie zum Back4app-Dashboard > App-Einstellungen > Servereinstellungen > Hintergrundjobs.
Planen Sie den Job, um täglich oder in einem von Ihnen gewählten Intervall ausgeführt zu werden.
Planung eines Cloud-Jobs
﻿
Schritt 9 – Integration von Webhooks
Definition
Webhooks ermöglichen es Ihrer Back4App-Anwendung, HTTP-Anfragen an einen externen Dienst (z. B. einen Slack-Kanal oder Stripe) zu senden, wenn bestimmte Ereignisse eintreten.
Konfiguration
Navigieren Sie zur Webhook-Konfiguration in Ihrem Back4App-Dashboard > Mehr > Webhooks.
Setzen Sie den Endpunkt (zum Beispiel, https://your-service.com/webhook-endpoint).
Konfigurieren Sie Trigger wie „Neuer Datensatz in der Todo-Klasse.“
Einen Webhook hinzufügen
﻿
Beispiel
Wenn Sie Daten an Slack senden möchten, wann immer ein Todo erstellt wird, können Sie einen neuen Webhook hinzufügen, der auf Ihre Slack-Eingangs-Webhook-URL zeigt. Sie können auch Webhooks im Cloud Code definieren, indem Sie benutzerdefinierte HTTP-Anfragen in Triggern wie afterSave senden.
BeforeSave WebHook
﻿
Schritt 10 – Erkundung des Back4App Admin Panels
Wo man es findet
Die Back4app Admin App ist eine benutzerfreundliche Oberfläche zur Verwaltung Ihrer Daten. Sie können sie aktivieren unter App Dashboard > Mehr > Admin App.
Admin App aktivieren
﻿
Funktionen
Erstellen Sie einen ersten Admin-Benutzer, der die Rolle B4aAdminUser und zusätzliche Klassen einrichtet.
Weisen Sie eine Subdomain zu zu, um auf die Admin-Oberfläche zuzugreifen.
Melden Sie sich an um Daten in einer einfachen Oberfläche anzuzeigen und zu verwalten.
﻿
Fazit
Indem Sie dieses Tutorial zur Erstellung eines Backends für Elixir mit Back4App befolgen, haben Sie:
Eine sichere Backend-Struktur auf der Plattform von Back4App mit Elixir für die Integration erstellt.
Eine Datenbank mit Klassen, Datentypen und Beziehungen eingerichtet.
REST/GraphQL verwendet, um mit Ihren Daten aus Elixir zu interagieren.
Sicherheit mit ACLs und CLPs angewendet.
Benutzerdefinierte Logik mit Cloud Code-Funktionen hinzugefügt.
Benutzerauthentifizierung mit E-Mail-Verifizierung und Passwortzurücksetzungen konfiguriert.
Dateispeicherung und -abruf verwaltet.
Hintergrundjobs für Automatisierung geplant.
Externe Dienste mit Webhooks integriert.
Das Back4App Admin Panel für eine einfache Datenverwaltung erkundet.
Mit dem Nebenläufigkeitsmodell von Elixir (betrieben von der Erlang-VM) und OTP, kombiniert mit den skalierbaren und flexiblen Diensten von Back4App, können Sie hochrobuste Backends erstellen.
Setzen Sie die Erkundung weiterer fortgeschrittener Funktionen fort, integrieren Sie Ihre Geschäftslogik und lassen Sie Back4App Ihnen helfen, die schwere Arbeit zu erledigen.
Nächste Schritte
Erstellen Sie eine produktionsbereite Elixir-App indem Sie dieses Backend mit Ihrem bevorzugten Elixir/Phoenix-Web-Framework kombinieren.
Integrieren Sie erweiterte Funktionen wie rollenbasierte Zugriffskontrolle oder Drittanbieter-APIs (Zahlungsgateways, Messaging-Dienste).
Durchsuchen Sie die offizielle Dokumentation von Back4app für erweiterte Sicherheit, Protokolle, Leistungsoptimierung und mehr.
Sehen Sie sich andere Tutorials an für Echtzeitanwendungen, IoT-Dashboards oder standortbasierte Dienste. Mit Mustererkennung und OTP-Konkurenz stehen Ihnen viele Anwendungsmöglichkeiten zur Verfügung!
﻿
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für Ruby erstellt?
ALS NÄCHSTES
Wie man ein Backend für das Play Framework erstellt?