Quickstarters
Come costruire un backend per Django?

40min
Introduzione
In questo tutorial, imparerai come costruire un backend per Django utilizzando la robusta piattaforma AI-powered di Back4App. 
Django è un framework web di alto livello che incoraggia uno sviluppo rapido del backend e un design pulito e pragmatico. 
Creeremo un backend scalabile e sicuro che si integra perfettamente con il tuo progetto Django. 
Utilizzando Back4App, puoi approfittare della gestione automatizzata del database, API potenti, archiviazione di file, autenticazione degli utenti, validazione dei dati, capacità in tempo reale e funzionalità di sicurezza avanzate.
Vedrai come l'ambiente di Back4App genera automaticamente l'infrastruttura del server, permettendoti di concentrarti sulla logica aziendale della tua app Django. 
Questo approccio riduce i tempi di sviluppo eliminando la necessità di configurare manualmente server e database. 
Alla fine di questo tutorial, avrai una struttura robusta per le tue applicazioni web che può essere estesa con funzionalità più complesse, integrazioni e logica personalizzata.
Requisiti
Un account Back4App e un nuovo progetto Back4App
Iniziare con Back4App.
Se non hai un account, puoi crearne uno gratuitamente. Segui la guida sopra per preparare il tuo progetto.
Un progetto Django configurato localmente
Assicurati di avere un ambiente Django. Se stai partendo da zero, segui la documentazione ufficiale di Django. Conferma che le INSTALLED_APPS del tuo progetto e la base della struttura delle viste e dei template siano pronte.
Python 3.7+ installato
Avrai bisogno di un ambiente Python moderno per la tua app Django.
Familiarità con l’ architettura del modello di vista di Django e le operazioni CRUD di base
Se sei nuovo in Django o hai bisogno di rinfrescarti, dai un'occhiata a la documentazione di Django.﻿
Avere questi requisiti in atto garantirà un'esperienza più fluida mentre segui questo tutorial.
Passo 1 – Creare un Nuovo Progetto su Back4App e Connettersi
Perché Hai Bisogno di un Progetto Back4App
Un nuovo progetto su Back4App è la spina dorsale dello sviluppo del tuo backend. Ti fornisce capacità del Parse Server, strumenti per il database e un'interfaccia di amministrazione potente. 
Questa struttura centrale ti consente di delegare la gestione del server e concentrarti sulla logica aziendale della tua app Django.
Crea un Nuovo Progetto
Accedi al tuo account Back4App.
Clicca sul pulsante “Nuova App” nella tua dashboard di Back4App.
Dai un nome alla tua app (ad esempio, “Django-Backend-Tutorial”).
﻿
Una volta creata, la tua app apparirà nella tua dashboard di Back4App. Questo nuovo progetto è dove memorizzeremo i dati, gestiremo le regole di sicurezza e eseguiremo codice lato server per la tua app Django.
Installazione del Parse Python SDK
Per collegare il tuo progetto Django a Back4App, utilizzeremo il Parse Python SDK. Ti consente di gestire operazioni sui dati, autenticazione degli utenti, funzionalità in tempo reale e altro ancora all'interno del tuo codice Python.
Recupera le tue chiavi App:
Nella dashboard di Back4App, vai a Impostazioni App o Sicurezza e Chiavi per trovare il tuo ID Applicazione e Chiave Client (o Chiave REST) e l'URL del Server Parse (ad esempio, https://parseapi.back4app.com).
﻿
Installa il SDK:
Bash
pip install parse_rest
pip install parse_rest
﻿
Inizializza Parse nel tuo progetto Django. Ad esempio, crea un nuovo file chiamato parse_config.py all'interno della directory principale della tua app Django (la stessa cartella che contiene views.py o 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)
﻿
Con questa configurazione, qualsiasi file nel tuo progetto Django può importare parse_config per garantire una connessione al tuo backend Back4App. Ora puoi interrogare e salvare dati dal tuo codice Django utilizzando il Parse Python SDK.
Passo 2 – Configurazione del Database
1. Creazione di un Modello di Dati
Proprio come Django utilizza i modelli per memorizzare i dati in un database relazionale, Parse utilizza le classi per memorizzare gli oggetti. Puoi creare classi nel dashboard di Back4App o definirle al volo.
Nel Dashboard di Back4App
Naviga verso Database
Clicca su Crea una Classe
Nominala (ad esempio, “Todo”), poi aggiungi campi come title (Stringa) e isCompleted (Booleano).
Crea Nuova Classe
﻿
2. Utilizzare l'Agente AI per Generare Automaticamente un Modello di Dati
L'Agente AI di Back4App può aiutarti a generare automaticamente uno schema:
Apri l'Agente AI nel tuo Dashboard dell'App.
Descrivi il tuo modello di dati (ad esempio, “Uno schema di app Todo con title, isCompleted e puntatore utente.”).
Lascia che l'Agente AI lo costruisca per te.
﻿
Questo può far risparmiare tempo, specialmente se la tua app Django richiede relazioni complesse o una validazione avanzata dei dati.
3. Leggere e Scrivere Dati utilizzando il Parse SDK
Di seguito è riportato un esempio di creazione e interrogazione di un Todo oggetto all'interno del tuo progetto Django:
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
﻿
Puoi chiamare queste funzioni dalle tue viste Django o dalla shell. Questa configurazione funziona in tandem con la logica della tua app Django, quindi il tuo framework web rimane completamente integrato con il backend Parse.
4. Lettura e Scrittura di Dati Utilizzando l'API REST
Se preferisci REST, ecco come creare un Todo oggetto:
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. Lettura e Scrittura di Dati Utilizzando l'API GraphQL
Back4App fornisce anche un GraphQL interfaccia. Ad esempio:
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
    }
  }
}
﻿
Questo è utile se desideri integrare le query GraphQL nelle tue viste Django o microservizi come parte di un'architettura dati moderna.
6. Lavorare con le Query Live (opzionale)
Per aggiornamenti in tempo reale, puoi abilitare le Query Live nel dashboard di Back4App. Al momento, l'SDK ufficiale di Parse per Python potrebbe avere un supporto limitato per le Query Live. Tuttavia, puoi comunque iscriverti ai cambiamenti tramite WebSocket o altri approcci se necessario. Controlla la Documentazione di Back4App per gli ultimi aggiornamenti sulle Query Live in Python.
Passo 3 – Applicare la Sicurezza con ACL e CLP
1. Breve Panoramica
Usa Liste di Controllo degli Accessi (ACL) e Permessi a Livello di Classe (CLP) per proteggere i tuoi dati. Le ACL controllano i permessi di lettura/scrittura per oggetto, mentre i CLP si applicano a un'intera classe.
﻿
2. Passo dopo passo
Impostare i permessi a livello di classe:
Vai alla sezione Database in Back4App.
Scegli la classe (ad esempio, Todo).
Regola l'accesso Lettura/Scrittura o richiedi il login.
Configurare le ACL nel codice:
Questo assicura che il tuo progetto Django rispetti le stesse regole di sicurezza granulari impostate in Back4App.
Passo 4 – Scrivere funzioni di Cloud Code
1. Perché Cloud Code
Con Cloud Code, esegui logica aziendale sul lato server. Ad esempio, puoi eseguire la validazione dei dati, integrare API esterne o attivare eventi prima di salvare i dati. Questo è un potente complemento per le tue viste e modelli Django, permettendoti di centralizzare la logica avanzata in un unico posto.
2. Funzione di Esempio
Cloud Code è tipicamente scritto in JavaScript. Lo distribuisci su Back4App e poi lo chiami dalla tua app Django tramite il Parse Python SDK o richieste REST. Una funzione semplice:
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. Distribuzione
Usa il Back4App CLI o Dashboard.
Distribuisci il tuo main.js con funzioni cloud.
Una volta distribuiti, diventano accessibili al tuo codice Django tramite:
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
Se hai bisogno di moduli Node esterni nel tuo Cloud Code, dichiarali nel package.json. Back4App li installa automaticamente al momento della distribuzione.
Passo 5 – Configurazione dell'autenticazione
1. Abilitare o configurare l'autenticazione dell'utente
Per impostazione predefinita, Parse include la User classe per le registrazioni e i login. Configura la verifica dell'email, il ripristino della password e altro nel dashboard di Back4App.
2. Esempi di codice Django
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. Accesso sociale
Se hai bisogno di accessi tramite Google, Apple o Facebook, configurali in Impostazioni di autenticazione di Back4App e segui le rispettive guide. La tua app Django può quindi collegare o accedere agli utenti chiamando i metodi Parse pertinenti.
Passo 6 – Gestione dello storage dei file
1. Configurazione dello Storage dei File
Back4App memorizza in modo sicuro i file caricati tramite il Parse SDK. Puoi caricare da Django inviando un file a un campo File di Parse:
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. Esempio
Se desideri aggiungere immagini caricate dagli utenti, integra un <input type="file"> nei tuoi template Django, quindi gestisci il file in una funzione di vista che chiama upload_image().
3. Considerazioni sulla Sicurezza
Parse fornisce una configurazione che controlla chi può caricare file:
JSON
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
﻿
Regola queste impostazioni per soddisfare le tue esigenze di sicurezza, assicurandoti che solo gli utenti fidati possano memorizzare e accedere a file sensibili.
Passo 7 – Verifica Email e Ripristino Password
1. Panoramica
L' interfaccia di amministrazione di Django gestisce molte cose, ma per il tuo backend alimentato da Parse, puoi anche abilitare la verifica email e il ripristino delle password. È fondamentale per verificare utenti reali e fornire un percorso di recupero dell'account fluido.
2. Configurazione del Dashboard
Apri la tua app Back4App
Abilita la Verifica Email in Impostazioni App > Impostazioni Email
Personalizza i template email per adattarli al tuo branding
3. Codice/Implementazione
Nella tua app Django, potresti offrire un modulo per il ripristino della password. Quando un utente richiede un ripristino, chiama l'endpoint di ripristino della password di Parse o il metodo Python appropriato se supportato nel SDK.
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
1. Cosa Fanno i Cloud Jobs
I Cloud Jobs ti permettono di eseguire compiti automatizzati, come la pulizia dei dati obsoleti o la generazione di report. Questo completa i crontab o i celery workflow di Django centralizzando i compiti nell'ambiente di Back4App.
2. Esempio
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.`;
});
﻿
Dopo il deploy, pianificalo nel Back4App Dashboard sotto Server Settings > Background Jobs per eseguirlo quotidianamente o settimanalmente.
Passo 9 – Integrazione dei Webhook
1. Definizione
I webhook ti permettono di inviare richieste HTTP a servizi esterni quando si verificano determinati eventi nelle tue classi di Back4App. Ad esempio, notifica un canale Slack o un servizio di pagamento ogni volta che viene creato un nuovo record.
2. Configurazione
Vai su More > WebHooks nel dashboard.
Imposta il tuo endpoint esterno (ad esempio, un URL nel tuo progetto Django).
Definisci i trigger (come “Oggetto Creato” in Todo).
Aggiunta di un Webhook
﻿
3. Esempio
Ogni volta che viene creato un nuovo Todo, una richiesta POST viene inviata all'endpoint della tua app Django. In Django, analizzeresti i dati JSON e li gestiresti (ad esempio, registrazione o ulteriore elaborazione).
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
1. Dove Trovarlo
L' App di Amministrazione di Back4App si trova nella tua console sotto Altro > App di Amministrazione. È un'interfaccia incentrata sul modello per gestire i tuoi dati senza scrivere codice.
Abilita l'App di Amministrazione
﻿
2. Caratteristiche
Database: Visualizza, modifica o elimina rapidamente i record.
Log: Monitora errori o log di processo.
Lavori in Background: Gestisci i programmi dei tuoi Cloud Jobs.
Analisi e Push: Se rilevante per la tua app, accedi alle notifiche push e ai dati analitici.
Questo è simile all' interfaccia di amministrazione di Django, ma si concentra sul backend di Parse.
Conclusione
Seguendo questa guida, hai imparato come costruire un backend per Django utilizzando Back4App. Hai:
Creato una struttura backend sicura e scalabile per la tua app Django.
Impostato un modello di dati, eseguito operazioni CRUD e sfruttato funzionalità in tempo reale.
Implementato ACL, CLP e autenticazione degli utenti per una sicurezza di alto livello.
Utilizzato Cloud Code per la logica aziendale, la convalida dei dati e integrazioni esterne.
Archiviato file, programmato Cloud Jobs e configurato Webhook per flussi di lavoro avanzati.
Esplorato l'app Admin di Back4App per gestire i tuoi dati in modo efficace.
Con questa base, puoi estendere con fiducia il tuo progetto Django. Integra funzionalità avanzate, ottimizza le prestazioni e aggiungi logica personalizzata per gestire requisiti a livello aziendale.
Continua a sperimentare con il Parse Python SDK per fornire potenti applicazioni web. Buon coding!
Prossimi Passi
Costruisci un'app Django pronta per la produzione con caching avanzato, ruoli utente e ottimizzazioni delle prestazioni.
Sfrutta funzionalità più avanzate di Back4App come analisi avanzate o controllo degli accessi basato sui ruoli.
Impara dalla documentazione ufficiale di Back4App per una conoscenza più approfondita di log, query in tempo reale e ottimizzazione dei dati.
Esplora altri tutorial per vedere come puoi combinare le potenti “views e templates” di Django con API esterne e m
﻿
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Java?
AVANTI IL PROSSIMO
Come costruire un backend per Flask?