Schnellstarter
Wie baut man ein Backend für Django?

40min
Einführung
In diesem Tutorial lernen Sie wie man ein Backend für Django mit der robusten, KI-gestützten Plattform von Back4App erstellt. 
Django ist ein hochentwickeltes Web-Framework, das eine schnelle Backend-Entwicklung und ein sauberes, pragmatisches Design fördert. 
Wir werden ein skalierbares und sicheres Backend erstellen, das nahtlos in Ihr Django-Projekt integriert ist. 
Durch die Verwendung von Back4App können Sie von automatisiertem Datenbankmanagement, leistungsstarken APIs, Dateispeicherung, Benutzerauthentifizierung, Datenvalidierung, Echtzeitfunktionen und erweiterten Sicherheitsfunktionen profitieren.
Sie werden sehen, wie die Umgebung von Back4App automatisch Serverinfrastruktur generiert, sodass Sie sich auf die Geschäftslogik Ihrer Django-App konzentrieren können. 
Dieser Ansatz verkürzt die Entwicklungszeit, indem die Notwendigkeit entfällt, Server und Datenbanken manuell einzurichten. 
Am Ende dieses Tutorials haben Sie eine robuste Struktur für Ihre Webanwendungen, die mit komplexeren Funktionen, Integrationen und benutzerdefinierter Logik erweitert werden kann.
Voraussetzungen
Ein Back4App-Konto und ein neues Back4App-Projekt
Erste Schritte mit Back4App.
Wenn Sie kein Konto haben, können Sie eines kostenlos erstellen. Folgen Sie dem obigen Leitfaden, um Ihr Projekt vorzubereiten.
Ein lokal eingerichtetes Django-Projekt
Stellen Sie sicher, dass Sie eine funktionierende Django-Umgebung. Wenn Sie von Grund auf neu beginnen, folgen Sie der offiziellen Dokumentation von Django. Bestätigen Sie, dass die INSTALLED_APPS Ihres Projekts und die grundlegende Struktur von Views und Templates bereit sind.
Python 3.7+ installiert
Sie benötigen eine moderne Python-Umgebung für Ihre Django-App.
Vertrautheit mit Djangos Modell-View Architektur und grundlegenden CRUD-Operationen
Wenn Sie neu bei Django sind oder Ihr Wissen auffrischen müssen, schauen Sie sich Djangos Dokumentation.﻿
Wenn Sie diese Voraussetzungen erfüllen, wird Ihr Erlebnis beim Befolgen dieses Tutorials reibungsloser.
Schritt 1 – Erstellen eines neuen Projekts auf Back4App und Verbindung herstellen
Warum Sie ein Back4App-Projekt benötigen
Ein neues Projekt auf Back4App ist das Rückgrat Ihrer Backend-Entwicklung. Es bietet Ihnen Parse Server-Funktionen, Datenbanktools und eine leistungsstarke Admin-Oberfläche. 
Diese zentrale Struktur ermöglicht es Ihnen, das Servermanagement auszulagern und sich auf die Geschäftslogik Ihrer Django-App zu konzentrieren.
Erstellen Sie ein neues Projekt
Melden Sie sich bei Ihrem Back4App-Konto an.
Klicken Sie auf die Schaltfläche „Neue App“ in Ihrem Back4App-Dashboard.
Benennen Sie Ihre App (z. B. „Django-Backend-Tutorial“).
﻿
Sobald Ihre App erstellt ist, wird sie in Ihrem Back4App-Dashboard angezeigt. Dieses neue Projekt ist der Ort, an dem wir Daten speichern, Sicherheitsregeln verwalten und serverseitigen Code für Ihre Django-App ausführen.
Installation des Parse Python SDK
Um Ihr Django-Projekt mit Back4App zu verbinden, verwenden wir das Parse Python SDK. Es ermöglicht Ihnen, Datenoperationen, Benutzerauthentifizierung, Echtzeitfunktionen und mehr aus Ihrem Python-Code heraus zu verwalten.
Rufen Sie Ihre App-Schlüssel ab:
Gehen Sie im Back4App-Dashboard zu App-Einstellungen oder Sicherheit & Schlüssel um Ihre Anwendungs-ID und Client-Schlüssel (oder REST-Schlüssel) und die Parse-Server-URL (z. B. https://parseapi.back4app.com).
﻿
Installieren Sie das SDK:
Bash
pip install parse_rest
pip install parse_rest
﻿
Initialisiere Parse in deinem Django-Projekt. Zum Beispiel, erstelle eine neue Datei mit dem Namen parse_config.py im Hauptverzeichnis deiner Django-App (dem gleichen Ordner, der views.py oder models.py):
Python
# parse_config.py
from parse_rest.connection import register

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# Register your app with Parse
register(APPLICATION_ID, REST_API_KEY, master_key=None, endpoint=PARSE_SERVER_URL)
# parse_config.py
from parse_rest.connection import register

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# Register your app with Parse
register(APPLICATION_ID, REST_API_KEY, master_key=None, endpoint=PARSE_SERVER_URL)
﻿
Mit dieser Konfiguration kann jede Datei in deinem Django-Projekt parse_config importieren, um eine Verbindung zu deinem Back4App-Backend sicherzustellen. Du kannst jetzt Daten aus deinem Django-Code mit dem Parse Python SDK abfragen und speichern.
Schritt 2 – Datenbank einrichten
1. Erstellen eines Datenmodells
So wie Django Modelle verwendet, um Daten in einer relationalen Datenbank zu speichern, verwendet Parse Klassen, um Objekte zu speichern. Du kannst Klassen im Back4App-Dashboard erstellen oder sie spontan definieren.
Im Back4App Dashboard
Navigieren Sie zu Datenbank
Klicken Sie auf Klasse erstellen
Nennen Sie es (z.B. „Todo“), fügen Sie dann Felder wie title (String) und isCompleted (Boolean) hinzu.
Neue Klasse erstellen
﻿
2. Verwendung des KI-Agenten zur automatischen Generierung eines Datenmodells
Der KI-Agent von Back4App kann Ihnen helfen, automatisch ein Schema zu generieren:
Öffnen Sie den KI-Agenten in Ihrem App-Dashboard.
Beschreiben Sie Ihr Datenmodell (z.B. „Ein Todo-App-Schema mit Titel, isCompleted und Benutzerzeiger.“).
Lassen Sie den KI-Agenten es für Sie erstellen.
﻿
Dies kann Zeit sparen, insbesondere wenn Ihre Django-App komplexe Beziehungen oder erweiterte Datenvalidierung erfordert.
3. Lesen und Schreiben von Daten mit dem Parse SDK
Unten finden Sie ein Beispiel für das Erstellen und Abfragen eines Todo-Objekts innerhalb Ihres Django-Projekts:
Python
# views.py
from parse_config import *
from parse_rest.datatypes import Object

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    todo = Todo(title=title, isCompleted=is_completed)
    todo.save()  # This performs the CRUD operation to save data in Back4App

def get_all_todos():
    return Todo.Query.all()  # Retrieves all Todo objects from Back4App
# views.py
from parse_config import *
from parse_rest.datatypes import Object

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    todo = Todo(title=title, isCompleted=is_completed)
    todo.save()  # This performs the CRUD operation to save data in Back4App

def get_all_todos():
    return Todo.Query.all()  # Retrieves all Todo objects from Back4App
﻿
Sie können diese Funktionen von Ihren Django-Views oder der Shell aus aufrufen. Dieses Setup funktioniert in Verbindung mit der Logik Ihrer Django-App, sodass Ihr Web-Framework vollständig mit dem Parse-Backend integriert bleibt.
4. Daten lesen und schreiben mit der REST-API
Wenn Sie REST bevorzugen, hier ist, wie man ein Todo-Objekt erstellt:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
5. Daten lesen und schreiben mit der GraphQL-API
Back4App bietet auch eine GraphQL Schnittstelle. Zum Beispiel:
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
    }
  }
}
﻿
Dies ist nützlich, wenn Sie GraphQL-Abfragen in Ihren Django-Ansichten oder Mikrodiensten als Teil einer modernen Datenarchitektur integrieren möchten.
6. Arbeiten mit Live-Abfragen (optional)
Für Echtzeit-Updates können Sie Live-Abfragen aktivieren im Back4App-Dashboard. Im Moment könnte das offizielle Parse Python SDK eine begrenzte direkte Unterstützung für Live-Abfragen haben. Sie können jedoch weiterhin Änderungen über WebSockets oder andere Ansätze abonnieren, wenn nötig. Überprüfen Sie die Back4App-Dokumentation für die neuesten Updates zu Python Live-Abfragen.
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
1. Kurze Übersicht
Verwenden Sie Zugriffskontrolllisten (ACLs) und Klassenebene-Berechtigungen (CLPs) um Ihre Daten zu schützen. ACLs steuern die Lese-/Schreibberechtigungen pro Objekt, während CLPs für eine gesamte Klasse gelten.
﻿
2. Schritt-für-Schritt
Einrichten von Klassenebene-Berechtigungen:
Gehe zum Datenbank-Bereich in Back4App.
Wähle die Klasse (z.B. Todo).
Passe den Lese-/Schreib-Zugriff an oder fordere eine Anmeldung an.
Konfigurieren von ACLs im Code:
Dies stellt sicher, dass dein Django-Projekt die gleichen granularen Sicherheitsregeln beachtet, die in Back4App festgelegt sind.
Schritt 4 – Schreiben von Cloud-Code-Funktionen
1. Warum Cloud-Code
Mit Cloud-Code führst du Geschäftslogik auf der Serverseite aus. Zum Beispiel kannst du Datenvalidierung durchführen, externe APIs integrieren oder Ereignisse auslösen, bevor Daten gespeichert werden. Dies ist eine leistungsstarke Ergänzung zu deinen Django-Ansichten und -Vorlagen, die es dir ermöglicht, fortgeschrittene Logik an einem Ort zu zentralisieren.
2. Beispiel Funktion
Cloud Code wird typischerweise in JavaScript geschrieben. Sie stellen es bei Back4App bereit und rufen es dann von Ihrer Django-App über das Parse Python SDK oder REST-Anfragen auf. Eine einfache Funktion:
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 };
});
﻿
3. Bereitstellung
Verwenden Sie die Back4App CLI oder Dashboard.
Stellen Sie Ihre main.js mit Cloud-Funktionen bereit.
Sobald sie bereitgestellt sind, werden sie über Ihren Django-Code zugänglich:
Python
from parse_config import *
import requests

def call_calculate_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": APPLICATION_ID,
        "X-Parse-REST-API-Key": REST_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {"text": text}
    response = requests.post(url, json=payload, headers=headers)
    return response.json()
from parse_config import *
import requests

def call_calculate_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": APPLICATION_ID,
        "X-Parse-REST-API-Key": REST_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {"text": text}
    response = requests.post(url, json=payload, headers=headers)
    return response.json()
﻿
4. NPM
Wenn Sie externe Node-Module in Ihrem Cloud Code benötigen, deklarieren Sie sie in der package.json. Back4App installiert sie automatisch bei der Bereitstellung.
Schritt 5 – Authentifizierung konfigurieren
1. Benutzer-Authentifizierung aktivieren oder einrichten
Standardmäßig enthält Parse die Benutzer-Klasse für Anmeldungen und Logins. Konfigurieren Sie die E-Mail-Verifizierung, Passwortzurücksetzungen und mehr im Back4App-Dashboard.
2. Django-Codebeispiele
Python
# models.py or a separate file
from parse_config import *
from parse_rest.user import User

def register_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    return new_user

def login_user(username, password):
    return User.login(username, password)
# models.py or a separate file
from parse_config import *
from parse_rest.user import User

def register_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    return new_user

def login_user(username, password):
    return User.login(username, password)
﻿
3. Soziale Anmeldung
Wenn Sie Google-, Apple- oder Facebook-Anmeldungen benötigen, konfigurieren Sie diese in den Auth-Einstellungen von Back4App und folgen Sie den jeweiligen Anleitungen. Ihre Django-App kann dann Benutzer verknüpfen oder anmelden, indem sie die entsprechenden Parse-Methoden aufruft.
Schritt 6 – Dateispeicherung verwalten
1. Einrichtung der Dateispeicherung
Back4App speichert Dateien, die über das Parse SDK hochgeladen werden, sicher. Sie können von Django aus eine Datei an ein Parse-Dateifeld hochladen:
Python
from parse_rest.datatypes import Object, File

class Photo(Object):
    pass

def upload_image(file_path):
    with open(file_path, 'rb') as f:
        parse_file = File(file_path, f.read())

    photo = Photo(imageFile=parse_file)
    photo.save()
    return photo
from parse_rest.datatypes import Object, File

class Photo(Object):
    pass

def upload_image(file_path):
    with open(file_path, 'rb') as f:
        parse_file = File(file_path, f.read())

    photo = Photo(imageFile=parse_file)
    photo.save()
    return photo
﻿
2. Beispiel
Wenn Sie von Benutzern hochgeladene Bilder hinzufügen möchten, integrieren Sie ein <input type="file"> in Ihre Django-Vorlagen und verarbeiten Sie die Datei in einer View-Funktion, die upload_image() aufruft.
3. Sicherheitsüberlegungen
Parse bietet eine Konfiguration, die steuert, wer Dateien hochladen kann:
JSON
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
﻿
Passen Sie diese an Ihre Sicherheitsbedürfnisse an, um sicherzustellen, dass nur vertrauenswürdige Benutzer sensible Dateien speichern und darauf zugreifen können.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
1. Übersicht
Die Admin-Oberfläche von Django verwaltet viele Dinge, aber für Ihr von Parse unterstütztes Backend können Sie auch die E-Mail-Verifizierung und Passwortzurücksetzungen aktivieren. Es ist wichtig, um echte Benutzer zu verifizieren und einen reibungslosen Wiederherstellungsweg für Konten bereitzustellen.
2. Dashboard-Konfiguration
Öffnen Sie Ihre Back4App-App
Aktivieren Sie die E-Mail-Verifizierung in App-Einstellungen > E-Mail-Einstellungen
Passen Sie die E-Mail-Vorlagen an Ihr Branding an
3. Code/Implementierung
In Ihrer Django-App könnten Sie ein Passwort-Zurücksetzen-Formular anbieten. Wenn ein Benutzer eine Zurücksetzung anfordert, rufen Sie den Passwort-Zurücksetzen-Endpunkt von Parse oder die entsprechende Python-Methode auf, wenn sie im SDK unterstützt wird.
Schritt 8 – Aufgaben mit Cloud-Jobs planen
1. Was Cloud-Jobs tun
Cloud-Jobs ermöglichen es Ihnen, automatisierte Aufgaben auszuführen, wie das Bereinigen alter Daten oder das Generieren von Berichten. Dies ergänzt Djangos crontab oder celery Workflows, indem Aufgaben in der Umgebung von Back4App zentralisiert werden.
2. 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);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Nach der Bereitstellung planen Sie es im Back4App Dashboard unter Servereinstellungen > Hintergrundjobs um täglich oder wöchentlich ausgeführt zu werden.
Schritt 9 – Webhooks integrieren
1. Definition
Webhooks ermöglichen es Ihnen, HTTP-Anfragen an externe Dienste zu senden, wenn bestimmte Ereignisse in Ihren Back4App-Klassen auftreten. Zum Beispiel, benachrichtigen Sie einen Slack-Kanal oder einen Zahlungsdienst, wann immer ein neuer Datensatz erstellt wird.
2. Konfiguration
Gehen Sie zu Mehr > WebHooks im Dashboard.
Richten Sie Ihren externen Endpunkt ein (z. B. eine URL in Ihrem Django-Projekt).
Definieren Sie Trigger (wie „Objekt erstellt“ in Todo).
Einen Webhook hinzufügen
﻿
3. Beispiel
Wann immer ein neues Todo erstellt wird, wird eine POST-Anfrage an den Endpunkt Ihrer Django-App gesendet. In Django würden Sie die JSON-Daten analysieren und verarbeiten (z. B. Protokollierung oder weitere Verarbeitung).
Schritt 10 – Erkundung des Back4App Admin Panels
1. Wo man es findet
Die Back4App Admin App befindet sich in Ihrer Konsole unter Mehr > Admin App. Es ist eine modellzentrierte Schnittstelle zur Verwaltung Ihrer Daten, ohne Code schreiben zu müssen.
Admin App aktivieren
﻿
2. Funktionen
Datenbank: Anzeigen, bearbeiten oder Datensätze schnell löschen.
Protokolle: Überwachen Sie Fehler oder Prozessprotokolle.
Hintergrundjobs: Verwalten Sie die Zeitpläne Ihrer Cloud-Jobs.
Analytik & Push: Wenn relevant für Ihre App, greifen Sie auf Push-Benachrichtigungen und Analysedaten zu.
Dies ähnelt der eigenen Admin-Oberfläche, konzentriert sich jedoch auf das Parse-Backend.
Fazit
Indem Sie diesem Leitfaden folgen, haben Sie gelernt, wie man ein Backend für Django mit Back4App erstellt. Sie haben:
Eine sichere und skalierbare Backend-Struktur für Ihre Django-App erstellt.
Ein Datenmodell eingerichtet, CRUD-Operationen durchgeführt und Echtzeitfunktionen genutzt.
ACLs, CLPs und Benutzerauthentifizierung für hohe Sicherheit implementiert.
Cloud Code für Geschäftslogik, Datenvalidierung und externe Integrationen verwendet.
Dateien gespeichert, Cloud-Jobs geplant und Webhooks für fortgeschrittene Workflows konfiguriert.
Die Back4App Admin App erkundet, um Ihre Daten effektiv zu verwalten.
Mit diesem Fundament können Sie Ihr Django-Projekt selbstbewusst erweitern. Integrieren Sie fortgeschrittene Funktionen, optimieren Sie die Leistung und fügen Sie benutzerdefinierte Logik hinzu, um Anforderungen auf Unternehmensebene zu erfüllen.
Experimentieren Sie weiter mit dem Parse Python SDK, um leistungsstarke Webanwendungen zu liefern. Viel Spaß beim Programmieren!
Nächste Schritte
Eine produktionsbereite Django-App erstellen mit fortgeschrittener Caching, Benutzerrollen und Leistungsoptimierungen.
Nutzen Sie weitere fortgeschrittene Back4App-Funktionen wie erweiterte Analysen oder rollenbasierte Zugriffskontrolle.
Lernen Sie aus der offiziellen Back4App-Dokumentation für tiefere Kenntnisse über Protokolle, Echtzeitanfragen und Datenoptimierung.
Erforschen Sie andere Tutorials um zu sehen, wie Sie die leistungsstarken „Views und Templates“ von Django mit externen APIs kombinieren können.
﻿
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für Java erstellt?
ALS NÄCHSTES
Wie man ein Backend für Flask erstellt?