Quickstarters
Come creare un backend per Swift?

44min
Introduzione
In questo tutorial, imparerai come costruire un backend completo per un'applicazione Swift 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, le query in tempo reale (Live Queries) e altro—per creare un backend sicuro, scalabile e robusto che comunica senza problemi con la tua app client basata su Swift.
Sfruttando la rapida configurazione e l'ambiente intuitivo di Back4App, ridurrai drasticamente il tempo e lo sforzo richiesti rispetto alla configurazione manuale di server e database.
Durante il percorso, acquisirai esperienza pratica con funzionalità cruciali, inclusi avanzati strumenti di sicurezza, pianificazione di attività con Cloud Jobs e configurazione di webhook per integrazioni esterne.
Entro la fine di questo tutorial, sarai ben preparato per migliorare questo servizio backend fondamentale in un'applicazione pronta per la produzione o per incorporare facilmente logica personalizzata e API di terze parti secondo necessità.
Vedrai come lavorare con una piattaforma BaaS può trasformare lo sviluppo backend in un'esperienza più snella, specialmente quando si crea un backend rapido o qualsiasi altra app backend. Iniziamo!
Requisiti
Per completare questo tutorial, avrai bisogno di:
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 ambiente di sviluppo Swift
Puoi usare Xcode come IDE per creare applicazioni iOS o macOS utilizzando Swift. Assicurati di avere installata una versione stabile recente di Xcode sul tuo computer.
Familiarità con il linguaggio di programmazione Swift
Se sei nuovo a Swift, rivedi la Documentazione di Swift ufficiale o un tutorial per principianti prima di iniziare.
Parse Swift SDK
Se stai usando CocoaPods, aggiungi pod 'ParseSwiftOG' al tuo Podfile. Oppure, se stai usando Swift Package Manager, aggiungi .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0") alle tue dipendenze. Leggi di più nella Documentazione di Parse Swift.
Assicurati di avere tutti questi prerequisiti in atto prima di iniziare. Avere il tuo progetto Back4App configurato e il tuo ambiente Swift locale pronto ti aiuterà a seguire più facilmente.
Passo 1 – Creare un Nuovo Progetto su Back4App e connettersi
Il primo passo per costruire il tuo backend Swift su Back4App è creare un nuovo progetto. Questo progetto è la base per tutte le configurazioni del backend discusse in questo tutorial. Swift può connettersi senza problemi al tuo nuovo backend utilizzando il Parse Swift SDK. Vediamo come.
Crea un Nuovo Progetto
Accedi al tuo account Back4App.
Clicca sul pulsante “Nuova App” nel tuo dashboard di Back4App.
Dai un nome alla tua app (ad esempio, “Swift-Backend-Tutorial”).
﻿
Dopo la creazione, vedrai la nuova app elencata nel tuo dashboard. Qui configurerai il tuo database, le funzioni cloud e altre impostazioni cruciali per la tua app backend.
Collegare il Parse Swift SDK
Back4App è alimentato dalla Parse Platform, che fornisce la base per il tuo database, aggiornamenti in tempo reale, autenticazione e altro ancora. La tua applicazione Swift può connettersi a Back4App installando e inizializzando il Parse Swift SDK.
Recupera le tue chiavi Parse:
Nel tuo dashboard di Back4App, vai alle “Impostazioni App” o “Sicurezza e Chiavi” della tua app per trovare il tuo ID Applicazione e Chiave Client. Vedrai anche il tuo URL del Server Parse (spesso https://parseapi.back4app.com).
﻿
Installa il Parse Swift SDK:
Swift Package Manager (Consigliato):
Swift
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
﻿
CocoaPods:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Inizializza Parse nella tua App:
Puoi farlo nel punto di ingresso principale del tuo progetto Swift (ad esempio, AppDelegate.swift o la struct SwiftUI @main . Ad esempio:
Swift
import SwiftUI
import ParseSwift

@main
struct MyApp: App {
    init() {
        // Replace placeholders with your Back4App credentials
        ParseSwift.initialize(
            applicationId: "YOUR_APPLICATION_ID",
            clientKey: "YOUR_CLIENT_KEY",
            serverURL: URL(string: "https://parseapi.back4app.com")!
        )
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
import SwiftUI
import ParseSwift

@main
struct MyApp: App {
    init() {
        // Replace placeholders with your Back4App credentials
        ParseSwift.initialize(
            applicationId: "YOUR_APPLICATION_ID",
            clientKey: "YOUR_CLIENT_KEY",
            serverURL: URL(string: "https://parseapi.back4app.com")!
        )
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
Con questa configurazione, il tuo client Swift può ora inviare richieste sicure a Back4App. Hai stabilito una connessione robusta che semplifica le operazioni sui dati senza richiedere chiamate manuali REST o GraphQL (anche se puoi comunque usarle se lo desideri).
Passo 2 – Configurazione del Database
In questo passo, configurerai il tuo database backend su Back4App e vedrai come gestire i dati dal tuo codice Swift. Back4App utilizza il modello di dati Parse, permettendoti di memorizzare oggetti in strutture simili a classi. Swift può interagire facilmente con queste classi tramite il Parse Swift SDK.
Creazione di un Modello di Dati
Naviga nella sezione “Database” nel tuo dashboard di Back4App.
Crea una nuova classe (ad esempio, “Todo”).
Aggiungi colonne per i dati di cui hai bisogno, come “title” (String) e “isCompleted” (Boolean).
Crea Nuova Classe
﻿
Puoi anche lasciare che il Parse Swift SDK crei automaticamente queste colonne la prima volta che salvi un oggetto. In ogni caso, il tuo schema deve corrispondere ai dati che memorizzi affinché la tua app possa gestirli senza problemi.
Creare un Modello di Dati Utilizzando l'Agente AI
Back4App fornisce un Agente AI che può aiutarti a progettare il tuo modello di dati:
Apri l'Agente AI dal dashboard o dal menu della tua app.
Descrivi il tuo modello di dati in linguaggio naturale. Ad esempio: “Per favore crea un nuovo progetto Swift con uno schema di classe ToDo.”
Lascia che l'Agente AI crei lo Schema per te automaticamente.
﻿
Lettura e Scrittura dei Dati: Parse Swift SDK
Utilizzando il Parse Swift SDK, puoi creare una struct che conforma a ParseObject per rappresentare i tuoi dati. Ad esempio, se hai una Todo classe:
Swift
import ParseSwift

struct Todo: ParseObject {
    // ParseObject protocol properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}
import ParseSwift

struct Todo: ParseObject {
    // ParseObject protocol properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}
﻿
Crea un oggetto Todo e salva:
Swift
var newTodo = Todo()
newTodo.title = "Buy groceries"
newTodo.isCompleted = false

Task {
    do {
        let saved = try await newTodo.save()
        print("Saved:", saved)
    } catch {
        print("Error saving Todo:", error)
    }
}
var newTodo = Todo()
newTodo.title = "Buy groceries"
newTodo.isCompleted = false

Task {
    do {
        let saved = try await newTodo.save()
        print("Saved:", saved)
    } catch {
        print("Error saving Todo:", error)
    }
}
﻿
Interroga tutti gli elementi Todo:
Swift
Task {
    do {
        let todos = try await Todo.query().find()
        print("Todos:", todos)
    } catch {
        print("Error fetching:", error)
    }
}
Task {
    do {
        let todos = try await Todo.query().find()
        print("Todos:", todos)
    } catch {
        print("Error fetching:", error)
    }
}
﻿
Lettura e Scrittura dei Dati: REST API
Se preferisci richieste HTTP standard, puoi utilizzare la REST API. Ad esempio, per creare un nuovo Todo:
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": "Walk the dog", "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": "Walk the dog", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Lettura e Scrittura dei Dati: GraphQL API
GraphQL è supportato anche. Ecco un esempio di mutazione per creare un Todo:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Finish homework"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Finish homework"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Lavorare con le Query Live
Se la tua app Swift ha bisogno di aggiornamenti in tempo reale, Back4App supporta le Query Live. Per iOS:
Abilita le Query Live nelle Impostazioni del Server della tua app.
Collegati specificando Parse.liveQueryServerURL nella tua app:
Swift
Parse.configuration.serverURL = URL(string: "https://parseapi.back4app.com")!
Parse.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!
Parse.configuration.serverURL = URL(string: "https://parseapi.back4app.com")!
Parse.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!
﻿
Iscriviti agli aggiornamenti live:
Swift
let subscription = Todo.query()
.subscribeCallback { subscriptionState in
    switch subscriptionState {
    case .subscribed(let querySubscription):
        print("Subscribed to Todo changes!")
    default:
        break
    }
}
let subscription = Todo.query()
.subscribeCallback { subscriptionState in
    switch subscriptionState {
    case .subscribed(let querySubscription):
        print("Subscribed to Todo changes!")
    default:
        break
    }
}
﻿
Ora, ogni volta che un Todo viene creato, aggiornato o eliminato, riceverai aggiornamenti in tempo reale. Questo è particolarmente utile per funzionalità collaborative o sensibili al tempo nello sviluppo del tuo backend Swift.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Cosa Sono ACL e CLP?
Back4App utilizza Access Control Lists (ACL) e Class-Level Permissions (CLP) per proteggere i tuoi dati. Le ACL ti permettono di definire permessi per oggetto, mentre i CLP impostano regole di accesso predefinite per un'intera classe.
﻿
Permessi a Livello di Classe
Nel Dashboard di Back4App:
Vai a Database e seleziona una classe (ad esempio, “Todo”).
Apri Class-Level Permissions.
Configura restrizioni su lettura, scrittura o accesso pubblico.
Access Control Lists (ACL)
Quando crei o aggiorni un ParseObject in Swift, puoi impostare un ACL. Ad esempio:
Swift
var acl = ParseACL()
// Only let the current user read and write
acl.setReadAccess(userId: "CURRENT_USER_ID", value: true)
acl.setWriteAccess(userId: "CURRENT_USER_ID", value: true)

var todo = Todo()
todo.ACL = acl
var acl = ParseACL()
// Only let the current user read and write
acl.setReadAccess(userId: "CURRENT_USER_ID", value: true)
acl.setWriteAccess(userId: "CURRENT_USER_ID", value: true)

var todo = Todo()
todo.ACL = acl
﻿
Questo garantisce che solo l'utente specificato possa leggere o modificare quell'oggetto. Combinare ACL e CLP forma un modello di sicurezza robusto e stratificato per i dati della tua app.
Passo 4 – Scrivere Funzioni di Cloud Code
Perché Cloud Code?
Il Cloud Code ti consente di eseguire logica Swift lato server (o JavaScript se utilizzi lo stile originale del Cloud Code di Parse) senza esporre segreti al client. È perfetto per validazioni, trigger, attività programmate e altro.
Esempio di Funzione
Ecco un esempio basato su JavaScript, ma puoi anche lavorare in TypeScript o chiamare da Swift. Nella tua cartella Cloud Code di Back4App, crea main.js:
JS
Parse.Cloud.define("getTasksCount", async (request) => {
  const query = new Parse.Query("Todo")
  const count = await query.count({ useMasterKey: true })
  return count
})

Parse.Cloud.beforeSave("Todo", async (request) => {
  const todo = request.object
  if (!todo.get("title")) {
    throw "Cannot save a Todo without a title."
  }
})
Parse.Cloud.define("getTasksCount", async (request) => {
  const query = new Parse.Query("Todo")
  const count = await query.count({ useMasterKey: true })
  return count
})

Parse.Cloud.beforeSave("Todo", async (request) => {
  const todo = request.object
  if (!todo.get("title")) {
    throw "Cannot save a Todo without a title."
  }
})
﻿
Potresti voler installare i moduli NPM includendoli nel tuo package.json file, e poi chiamarli in main.js. Una volta distribuiti, puoi invocare queste funzioni dal tuo codice Swift usando callFunction.
Distribuzione
Distribuisci il tuo Cloud Code tramite:
Bash
b4a deploy
b4a deploy
﻿
Puoi anche distribuire tramite il dashboard di Back4App andando su Cloud Code > Funzioni. Incolla il tuo codice nell'editor online e clicca su Distribuisci.
Chiamare da Swift
Swift
Task {
    do {
        let result = try await ParseCloud.callFunction("getTasksCount", with: [String: Any]())
        print("Count:", result)
    } catch {
        print("Error calling cloud function:", error)
    }
}
Task {
    do {
        let result = try await ParseCloud.callFunction("getTasksCount", with: [String: Any]())
        print("Count:", result)
    } catch {
        print("Error calling cloud function:", error)
    }
}
﻿
Passo 5 – Configurazione dell'Autenticazione
Abilitare l'autenticazione dell'utente
Nel Dashboard, vedrai una classe predefinita _User per gli account utente. Attiva eventuali fornitori di autenticazione aggiuntivi (Apple, Facebook, Google, ecc.) nella Auth Settings della tua app, se necessario.
Registrazione e accesso (Swift)
Swift
struct User: ParseUser {
    var objectId: String?
    var username: String?
    var email: String?
    var password: String?
    var emailVerified: Bool?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
}

// Sign up
Task {
    do {
        var newUser = User()
        newUser.username = "alice"
        newUser.password = "p@ssword"
        let signedUp = try await newUser.signup()
        print("User signed up:", signedUp)
    } catch {
        print("Error signing up:", error)
    }
}

// Log in
Task {
    do {
        let user = try await User.login(username: "alice", password: "p@ssword")
        print("Logged in user:", user)
    } catch {
        print("Error logging in:", error)
    }
}
struct User: ParseUser {
    var objectId: String?
    var username: String?
    var email: String?
    var password: String?
    var emailVerified: Bool?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
}

// Sign up
Task {
    do {
        var newUser = User()
        newUser.username = "alice"
        newUser.password = "p@ssword"
        let signedUp = try await newUser.signup()
        print("User signed up:", signedUp)
    } catch {
        print("Error signing up:", error)
    }
}

// Log in
Task {
    do {
        let user = try await User.login(username: "alice", password: "p@ssword")
        print("Logged in user:", user)
    } catch {
        print("Error logging in:", error)
    }
}
﻿
Accesso sociale
Back4App supporta l'accesso OAuth con Google, Apple e Facebook. Configura questi fornitori nella tua pagina delle Auth impostazioni e utilizza il codice di integrazione Parse Swift pertinente nella tua app Swift (ad esempio, ParseFacebookUtils o ParseAppleUtils) per gestire i flussi di autenticazione. Per dettagli, consulta la Documentazione Accesso Sociale.
Passo 6 – Gestione dello storage dei file
Impostazione dello storage dei file
Puoi memorizzare immagini, video o qualsiasi file in Back4App. In Swift, hai ParseFile:
Swift
let imageData = Data(/* your image bytes */)
let parseFile = ParseFile(name: "photo.jpg", data: imageData)

Task {
    do {
        let savedFile = try await parseFile.save()
        print("File saved:", savedFile.url ?? "No URL")
    } catch {
        print("Error uploading file:", error)
    }
}
let imageData = Data(/* your image bytes */)
let parseFile = ParseFile(name: "photo.jpg", data: imageData)

Task {
    do {
        let savedFile = try await parseFile.save()
        print("File saved:", savedFile.url ?? "No URL")
    } catch {
        print("Error uploading file:", error)
    }
}
﻿
Poi puoi allegare questo file a un ParseObject e salvarlo. Recupera l'URL del file per visualizzarlo o scaricarlo altrove.
Considerazioni sulla Sicurezza
Per limitare l'accesso ai file, puoi utilizzare la configurazione dei file di Parse Server. Ad esempio, potresti consentire solo agli utenti autenticati di caricare file o specificare permessi di lettura/scrittura nel tuo codice Swift.
Passo 7 – Verifica Email e Ripristino Password
Perché Email di Verifica e Ripristino?
La convalida dell'email di un utente garantisce una casella di posta reale e attiva. Il ripristino della password aiuta i tuoi utenti a recuperare in modo sicuro l'accesso all'account se dimenticano le credenziali.
Configurazione in Back4App
Vai a Impostazioni Email e abilita Verifica Email. Modifica i tuoi modelli di email sia per la verifica che per il ripristino.
Attivare un Ripristino della Password da Swift
Swift
Task {
    do {
        try await User.passwordReset(email: "[email protected]")
        print("Password reset email sent!")
    } catch {
        print("Error requesting password reset:", error)
    }
}
Task {
    do {
        try await User.passwordReset(email: "alice@example.com")
        print("Password reset email sent!")
    } catch {
        print("Error requesting password reset:", error)
    }
}
﻿
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Cloud Jobs
Puoi pianificare compiti lato server su Back4App. Ad esempio, pulire dati obsoleti o inviare report settimanali. Definisci un lavoro nel tuo Cloud Code e pianificalo tramite la dashboard di Back4App.
JS
Parse.Cloud.job("cleanupOldTodos", async (request) => {
  const now = new Date()
  // Example logic: remove todos older than 30 days
  // Use Master Key for privileged operations
})
Parse.Cloud.job("cleanupOldTodos", async (request) => {
  const now = new Date()
  // Example logic: remove todos older than 30 days
  // Use Master Key for privileged operations
})
﻿
Poi, nelle Impostazioni Server di Back4App  > Lavori in Background, puoi pianificarlo per essere eseguito quotidianamente o a qualsiasi intervallo.
Pianificazione di un lavoro nel cloud
﻿
Passo 9 – Integrazione dei Webhook
Cosa sono i Webhook?
I webhook consentono alla tua app di inviare automaticamente dati a servizi esterni ogni volta che si verificano determinati eventi. Questo è perfetto per l'integrazione con Slack, Stripe o altre API di terze parti.
Configurazione
Nel tuo dashboard di Back4App, vai su Altro > Webhook.
Aggiungi un endpoint webhook (ad es., https://example.com/webhook).
Scegli i trigger (ad es., creazione di un oggetto in “Todo”).
Aggiunta di un Webhook
﻿
Per logica personalizzata, puoi anche inviare richieste a URL esterni nei trigger del Cloud Code:
Prima di Salvare WebHook
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
Cos'è il Pannello di Amministrazione?
L' App di Amministrazione di Back4App è un'interfaccia point-and-click per personale non tecnico o di supporto. Fornisce una semplice GUI per eseguire operazioni CRUD sui tuoi dati—ottima per gestire i dati al di fuori del tuo ambiente di sviluppo.
Abilitare l'App di Amministrazione
Vai al Dashboard dell'App > Altro > App di Amministrazione.
Abilita l'App di Amministrazione e scegli un sottodominio.
Crea un Utente Amministratore.
Abilita l'App di Amministrazione
﻿
Una volta attivata, chiunque abbia le credenziali appropriate può visualizzare e modificare i tuoi dati da un'interfaccia web user-friendly—senza codice richiesto.
Conclusione
Seguendo questo tutorial completo, hai imparato come costruire un backend per Swift utilizzando Back4App. In particolare, hai:
Creato un backend sicuro per la tua app Swift.
Configurato un database con schemi di classe e relazioni tra i dati.
Lavorato con query in tempo reale (Live Queries) per aggiornamenti immediati.
Impostato una sicurezza robusta con ACL e CLP.
Utilizzato Cloud Code per eseguire logica personalizzata sul lato server.
Implementato l'autenticazione degli utenti con verifica e reset della password.
Gestito caricamenti di file in modo sicuro.
Pianificato attività automatizzate con Cloud Jobs.
Imparato a conoscere i Webhook per integrare API esterne.
Esplorato il Pannello di Amministrazione per la gestione diretta dei dati.
Ora hai un servizio backend funzionale e scalabile per la tua applicazione Swift—uno che può essere facilmente esteso per gestire funzionalità più complesse, connettersi a servizi di terze parti o adattarsi a un traffico utente più intenso. Hai anche visto di persona come la combinazione delle funzionalità BaaS di Back4App e la sintassi moderna di Swift possano accelerare lo sviluppo del backend.
Prossimi Passi
Costruisci un'app Swift pronta per la produzione sviluppando la tua UI/UX.
Integra funzionalità avanzate come autenticazione specializzata (basata su ruoli, SSO) o logica Cloud Code aggiuntiva per regole specifiche del dominio.
Controlla la documentazione ufficiale di Back4App per approfondimenti su log, analisi o sicurezza avanzata.
Esplora altri tutorial su chat in tempo reale, dashboard IoT o app basate sulla posizione. Combina questi con API esterne per risolvere sfide del mondo reale.
Ecco come costruire un backend per Swift utilizzando Back4App! Buon coding!
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per SwiftUI?
AVANTI IL PROSSIMO
Come costruire un backend per Kotlin?