Quickstarters
Come costruire un backend per Python?

41min
Introduzione
In questo tutorial passo dopo passo, imparerai a costruire un backend completo per applicazioni Python utilizzando Back4App.
Esploreremo l'integrazione delle funzionalità essenziali di Back4App—come la gestione del database, le Funzioni Cloud Code, le API REST e GraphQL, l'autenticazione degli utenti e le query in tempo reale—per creare un backend sicuro, scalabile e robusto che comunica senza problemi con il tuo codice Python.
Python è una scelta popolare tra i linguaggi di programmazione per lo sviluppo backend perché offre semplicità e la possibilità di mantenere facilmente il lato server.
Framework e librerie come Django, Flask e altri hanno a lungo reso Python una scelta privilegiata per i processi di sviluppo web.
Sfruttando Back4App, uno sviluppatore Python può rapidamente impostare uno schema di database, garantire l'integrità dei dati e persino incorporare compiti di machine learning senza dover gestire infrastrutture complesse.
Durante il percorso, acquisirai esperienza pratica con funzionalità chiave, come funzionalità di sicurezza avanzate, pianificazione di compiti con Cloud Jobs e impostazione di webhook per integrazioni esterne.
Alla fine di questo tutorial, sarai ben preparato per migliorare questa struttura fondamentale in un'applicazione backend Python pronta per la produzione o per integrarti facilmente con altri strumenti come Docker e Kubernetes man mano che il tuo progetto cresce.
Questo darà il via al tuo viaggio nello sviluppo backend Python utilizzando una piattaforma affidabile e robuste librerie Python.
Requisiti
Per completare questo tutorial, avrai bisogno di:
Un account Back4App e un nuovo progetto Back4App
Iniziare con Back4App.
Registrati gratuitamente se non lo hai già fatto e crea un nuovo progetto.
Python 3.x installato
Assicurati di avere Python 3.x configurato sul tuo computer. Scarica Python.﻿
Il Parse Python SDK
Installa tramite pip con pip install parse-rest. Useremo questo SDK per le interazioni con i dati.
Familiarità con i concetti di base di Python
Se sei nuovo in Python, rivedi la Documentazione ufficiale di Python. o un tutorial per principianti.
Avere questi requisiti in atto garantirà che tu possa seguire mentre esploriamo come costruire un backend per Python su Back4App.
Passo 1 – Configurare il progetto Back4App
Crea un nuovo progetto
Il primo passo per costruire il tuo backend Python su Back4App è creare un nuovo progetto. Se non ne hai già creato uno, segui questi passaggi:
Accedi al tuo account Back4App.
Clicca sul pulsante “Nuova App” nel tuo dashboard di Back4App.
Dai un nome alla tua app (ad esempio, “Python-Backend-Tutorial”).
﻿
Una volta creato il progetto, lo vedrai elencato nel tuo dashboard di Back4App. Questo progetto sarà la base per tutte le configurazioni del backend discusse in questo tutorial.
Collegare il Parse SDK
Back4App si basa sulla Parse Platform per gestire i tuoi dati, fornire funzionalità in tempo reale, gestire l'autenticazione degli utenti e altro ancora.
Per collegare il tuo codice Python a Back4App, devi installare il relativo Parse SDK e inizializzarlo con le credenziali dal tuo dashboard di Back4App.
Recupera le tue chiavi Parse:
Nel tuo dashboard di Back4App, vai alla sezione Impostazioni dell'app o Sicurezza e chiavi per trovare il tuo ID applicazione e Chiave API REST. Troverai anche l'URL del server Parse (spesso https://parseapi.back4app.com).
﻿
Installa il Parse REST Python SDK:
Bash
pip install parse-rest
pip install parse-rest
﻿
Inizializza Parse nel tuo script Python:
Tipicamente, creeresti un file (ad esempio, parse_config.py) nel tuo progetto:
parse_config.py
# parse_config.py
from parse_rest.connection import register

# Replace the placeholders with your Back4App credentials
APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# The register function initializes the connection
register(APPLICATION_ID, REST_API_KEY, master_key=None)
# parse_config.py
from parse_rest.connection import register

# Replace the placeholders with your Back4App credentials
APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# The register function initializes the connection
register(APPLICATION_ID, REST_API_KEY, master_key=None)
﻿
Questo codice garantisce che ogni volta che importi il tuo parse_config modulo altrove nella tua applicazione Python, sia preconfigurato per connettersi alla tua specifica istanza di Back4App. Hai ora stabilito una connessione sicura tra il tuo codice Python e il backend di Back4App.
Passo 2 – Configurazione del Database
Uno schema di database robusto è essenziale per lo sviluppo del backend Python. Le funzionalità di gestione dei dati di Back4App ti consentono di definire tabelle (classi), campi e relazioni, assicurandoti di poter facilmente memorizzare e recuperare dati nel tuo framework web Python o in qualsiasi altra libreria Python tu scelga.
Creazione di un Modello di Dati
Back4App crea automaticamente schemi di classe quando salvi per la prima volta un oggetto dal codice, oppure puoi definire uno schema nella dashboard:
Naviga nella sezione “Database” nel tuo dashboard di Back4App.
Crea una nuova classe (ad esempio, “Todo”) e aggiungi colonne pertinenti, come titolo (String) e isCompleted (Boolean).
Crea Nuova Classe
﻿
Creare un Modello di Dati utilizzando l'Agente AI
L'Agente AI di Back4App può aiutarti a creare rapidamente uno schema di database:
Apri l'Agente AI dal tuo Dashboard dell'App.
Descrivi il tuo modello di dati in linguaggio naturale (ad esempio, “Crea un'App ToDo con uno schema di classe completo.”).
Lascia che l'Agente AI generi automaticamente il tuo schema.
﻿
Leggere e Scrivere Dati utilizzando il Python Parse SDK
Una volta che il tuo schema è pronto, salvare e interrogare i dati è semplice. Ad esempio:
models.py
from parse_rest.datatypes import Object
import parse_config  # ensure parse_config is imported

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    new_todo = Todo(title=title, isCompleted=is_completed)
    new_todo.save()
    print("Todo saved successfully:", new_todo.objectId)

def fetch_todos():
    return Todo.Query.all()

# Usage
# create_todo_item("Buy groceries", False)
# results = fetch_todos()
# for todo in results:
#     print(todo.title, todo.isCompleted)
from parse_rest.datatypes import Object
import parse_config  # ensure parse_config is imported

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    new_todo = Todo(title=title, isCompleted=is_completed)
    new_todo.save()
    print("Todo saved successfully:", new_todo.objectId)

def fetch_todos():
    return Todo.Query.all()

# Usage
# create_todo_item("Buy groceries", False)
# results = fetch_todos()
# for todo in results:
#     print(todo.title, todo.isCompleted)
﻿
Lettura e scrittura di dati utilizzando l'API REST
Se preferisci interagire tramite REST, puoi inviare richieste direttamente:
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
﻿
Lettura e scrittura di dati utilizzando l'API GraphQL
Back4App fornisce anche un endpoint GraphQL per interrogare e modificare i dati:
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
    }
  }
}
﻿
Lavorare con le query live (opzionale)
Le query live ti permettono di ricevere aggiornamenti in tempo reale ogni volta che i dati cambiano. Per abilitarle:
Attiva le Query Live nel tuo Back4App Impostazioni del server.
Utilizza un approccio WebSocket in Python per iscriversi alle modifiche. Anche se il SDK Python per le Query Live è gestito dalla comunità, puoi integrare una libreria WebSocket se la tua applicazione richiede aggiornamenti in tempo reale.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Panoramica Breve
Back4App fornisce Liste di Controllo degli Accessi (ACL) e Permessi a Livello di Classe (CLP) per aiutarti a garantire l'integrità dei dati. Queste funzionalità definiscono come gli utenti pubblici o gli utenti autenticati possono accedere o modificare i dati.
﻿
Impostare i Permessi a Livello di Classe
Vai al tuo Dashboard di Back4App, seleziona la tua app e apri la Database sezione.
Seleziona una classe (ad esempio, “Todo”).
Vai ai Permessi a Livello di Classe e configura le regole per gli utenti pubblici o autenticati.
Configurare le ACL nel Codice
Le ACL sono permessi dettagliati impostati su singoli oggetti. Ad esempio:
Python
from parse_rest.datatypes import Object, ACL
from parse_rest.user import User
import parse_config

class TodoACL(Object):
    pass

def create_private_todo(title, owner):
    todo = TodoACL(title=title)
    # Create ACL that allows only the owner read/write
    acl = ACL()
    acl.set_read_access(owner.objectId, True)
    acl.set_write_access(owner.objectId, True)
    todo.ACL = acl
    todo.save()
    return todo
from parse_rest.datatypes import Object, ACL
from parse_rest.user import User
import parse_config

class TodoACL(Object):
    pass

def create_private_todo(title, owner):
    todo = TodoACL(title=title)
    # Create ACL that allows only the owner read/write
    acl = ACL()
    acl.set_read_access(owner.objectId, True)
    acl.set_write_access(owner.objectId, True)
    todo.ACL = acl
    todo.save()
    return todo
﻿
Con le ACL e le CLP, puoi trovare un equilibrio tra sicurezza e comodità quando costruisci le tue applicazioni Python.
Passo 4 – Scrivere Funzioni di Cloud Code
Perché Cloud Code
Il Cloud Code ti consente di scaricare logiche aziendali importanti sul lato server. Questo potrebbe comportare validazioni, trigger o compiti sofisticati come l'integrazione di strumenti di machine learning o API esterne con lo sviluppo del tuo backend Python.
Funzione di Esempio
Potresti scrivere le tue funzioni in main.js (Cloud Code basato su JavaScript) su Back4App. Nota che mentre sviluppi la tua applicazione in Python, l'ambiente Cloud Code su Back4App utilizza Node.js/JavaScript. Puoi chiamare queste funzioni dal tuo codice Python o da qualsiasi altro client.
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 };
});
﻿
Puoi chiamare questa funzione utilizzando le capacità REST o GraphQL di Python:
Python
import requests

def get_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "application/json"
    }
    response = requests.post(url, headers=headers, json={"text": text})
    data = response.json()
    return data.get("result", {})

# usage
length_info = get_text_length("Hello Back4App")
print(length_info.get("length"))
import requests

def get_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "application/json"
    }
    response = requests.post(url, headers=headers, json={"text": text})
    data = response.json()
    return data.get("result", {})

# usage
length_info = get_text_length("Hello Back4App")
print(length_info.get("length"))
﻿
Distribuzione e NPM
Il Cloud Code di Back4App viene distribuito utilizzando il Back4App CLI o tramite la dashboard. Puoi installare pacchetti NPM (ad esempio, per la manipolazione dei dati, chiamate API esterne) e farvi riferimento nel tuo main.js. Questo approccio mantiene il tuo codice efficiente e sicuro sul lato server.
Passo 5 – Configurazione dell'autenticazione
Abilita o Configura l'Autenticazione Utente
Back4App sfrutta la classe Parse User per l'autenticazione. Questo gestisce automaticamente l'hashing delle password, i token di sessione e altro ancora. Puoi gestire le registrazioni, i login o i ripristini delle password con un sovraccarico minimo.
Registrati e Accedi da Python
Python
from parse_rest.user import User
import parse_config

def sign_up_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    print("User signed up successfully:", new_user.objectId)
    return new_user

def log_in_user(username, password):
    logged_user = User.login(username, password)
    print("User logged in:", logged_user.username)
    return logged_user
from parse_rest.user import User
import parse_config

def sign_up_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    print("User signed up successfully:", new_user.objectId)
    return new_user

def log_in_user(username, password):
    logged_user = User.login(username, password)
    print("User logged in:", logged_user.username)
    return logged_user
﻿
Le sessioni sono gestite automaticamente da Parse. Puoi tenere traccia dell'utente connesso e chiamare .logout() quando necessario. Per ulteriori dettagli, consulta la documentazione della classe Utente.
Accesso Sociale
Puoi integrare fornitori popolari (come Facebook o Google) configurando i flussi OAuth o utilizzando adattatori specializzati. Fai riferimento alla documentazione dell'accesso sociale per ulteriori dettagli su come impostare queste funzionalità con il tuo progetto Python.
Passo 6 – Gestione dello Storage dei File
Impostazione dello Storage dei File
La piattaforma Parse include uno storage di file nativo:
Python
import requests
import parse_config

def upload_file(file_path):
    file_name = file_path.split('/')[-1]
    url = f"https://parseapi.back4app.com/files/{file_name}"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "image/jpeg" # or other mime type
    }
    with open(file_path, 'rb') as f:
        response = requests.post(url, headers=headers, data=f)
    return response.json().get('url')
import requests
import parse_config

def upload_file(file_path):
    file_name = file_path.split('/')[-1]
    url = f"https://parseapi.back4app.com/files/{file_name}"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "image/jpeg" # or other mime type
    }
    with open(file_path, 'rb') as f:
        response = requests.post(url, headers=headers, data=f)
    return response.json().get('url')
﻿
Esempio
Puoi allegare questo file a un oggetto Parse memorizzando il suo URL. Questo mantiene i tuoi dati coerenti mentre i tuoi media sono ospitati in sicurezza da Back4App.
Considerazioni sulla Sicurezza
Puoi controllare chi può caricare o accedere ai file configurando le impostazioni del tuo server Parse per consentire solo agli utenti autenticati, ad esempio. Questo approccio garantisce che le tue applicazioni Python in produzione rimangano sicure.
Passo 7 – Verifica Email e Ripristino Password
Panoramica
La verifica dell'email e il ripristino delle password sono cruciali per la gestione degli utenti. Aiutano a confermare le identità degli utenti e a mantenere la sicurezza dell'account.
Configurazione del Dashboard di Back4App
Abilita la Verifica Email in Impostazioni App > Impostazioni Email.
Configura i modelli di email, come l'indirizzo “Da”, e le istruzioni per il ripristino della password.
Implementazione del Codice
Da Python, puoi attivare le email di ripristino della password tramite l'endpoint REST o le librerie parse. Ad esempio:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Questo garantisce un flusso senza soluzione di continuità per il ripristino delle password direttamente dal tuo backend Python o da qualsiasi altra interfaccia.
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Cosa Fanno i Cloud Jobs
I Cloud Jobs ti permettono di automatizzare compiti, come la pulizia di vecchi record o la generazione di report periodici. Questi vengono eseguiti sull'infrastruttura di Back4App a intervalli specificati.
Esempio
Nel tuo main.js:
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);
  }
});
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);
  }
});
﻿
Puoi quindi pianificare questo lavoro per essere eseguito quotidianamente o settimanalmente utilizzando la Sezione Lavori in Background del pannello di controllo di Back4App.
Pianificazione di un Lavoro Cloud
﻿
Passo 9 – Integrazione dei Webhook
Definizione
I webhook consentono alla tua app Back4App di notificare servizi esterni quando si verificano determinati eventi. Questo è utile per integrarsi con gateway di pagamento o piattaforme di analisi, espandendo i tuoi processi di sviluppo.
Configurazione
Naviga verso Webhooks nel tuo dashboard di Back4App.
Aggiungi un nuovo webhook endpoint (ad esempio, https://your-service.com/webhook-endpoint).
Seleziona gli eventi che attivano il webhook (ad esempio, creazione o aggiornamenti di oggetti).
Aggiunta di un Webhook
﻿
Puoi anche definire webhook nei trigger del Cloud Code come beforeSave o afterSave per inviare dati a API esterne.
Webhook BeforeSave
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
Dove Trovarlo
L' App di Amministrazione di Back4App è un'interfaccia di gestione basata sul web. Consente al tuo team di eseguire operazioni CRUD, gestire dati e gestire attività quotidiane senza scrivere codice aggiuntivo. Questo può semplificare il tuo processo di sviluppo del backend Python.
Caratteristiche
Abilita l'App Admin da App Dashboard > Altro > App Admin e segui i passaggi:
Abilita App Admin
﻿
Crea il primo Utente Admin. Un nuovo ruolo (B4aAdminUser) e classi vengono aggiunti automaticamente al tuo schema.
﻿
Scegli un sottodominio per la tua interfaccia admin e finalizza. Poi accedi per utilizzare la tua nuova App Admin.
﻿
﻿
L'App Admin rende facile aggiornare o rimuovere record e gestire i tuoi dati. Con i giusti controlli di accesso, è sicuro condividerla con i project manager o gli stakeholder.
Conclusione
Seguendo questa guida su come costruire un backend per Python, hai:
Creato un backend sicuro per applicazioni Python su Back4App.
Configurato un database con schemi e relazioni flessibili.
Implementato query in tempo reale per aggiornamenti istantanei dei dati (opzionale con Live Queries).
Applicato misure di sicurezza con ACL e CLP per proteggere i dati.
Scritto Cloud Code in JavaScript per gestire la logica lato server, facilmente richiamabile da Python.
Impostato l'autenticazione degli utenti con verifica email e flussi di reset della password.
Gestito caricamenti di file nel tuo codice Python con sicurezza dei file opzionale.
Pianificato lavori ricorrenti per compiti automatizzati.
Integrato servizi esterni utilizzando webhook.
Esplorato il Pannello di Amministrazione per la gestione dei dati e la collaborazione.
Con una solida base di codice Python e un robusto backend Back4App, sei ora attrezzato per affrontare strutture dati avanzate, incorporare framework come Django e Flask, e persino integrare il machine learning. 
Python offre innumerevoli possibilità e combinarlo con Back4App significa che puoi iterare rapidamente concentrandoti sulla logica aziendale principale piuttosto che sulla manutenzione del server.
Prossimi Passi
Costruisci un'app Python pronta per la produzione affinando il tuo schema di database, aggiungendo caching e gestendo le ottimizzazioni delle prestazioni.
Esplora funzionalità avanzate come il controllo degli accessi basato sui ruoli, il logging avanzato o la connessione a API di terze parti per l'analisi.
Rivedi la documentazione ufficiale di Back4App per approfondimenti su sicurezza, ottimizzazione delle prestazioni e analisi dei log.
Sperimenta con strumenti come Docker e Kubernetes per containerizzare e scalare la tua applicazione secondo necessità.
Sfruttando le potenti librerie di Python e l'infrastruttura scalabile di Back4App, puoi accelerare il tuo percorso di sviluppo backend con fiducia.
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Flask?
AVANTI IL PROSSIMO
Come costruire un backend per Astro?