Come costruire un backend per un’applicazione mobile?

In questo articolo scoprirete cos’è un backend per un’applicazione mobile e ciò che dovete sapere per costruire il vostro backend.

Analizzeremo le differenze tra un backend e un frontend, i diversi tipi di backend, impareremo a conoscere le funzionalità di un backend per dispositivi mobili e i costi di sviluppo di un backend.

Infine, impareremo a costruire un backend per una semplice applicazione mobile su Back4app, uno dei migliori fornitori di MBaaS.

Differenze tra frontend e backend

I termini frontend e backend si riferiscono alla separazione dei problemi tra il livello di presentazione e il livello di accesso ai dati.

Il modo più semplice per capire quali sono le differenze è immaginare un iceberg. Il frontend si trova sopra il livello dell’acqua ed è tutto ciò che l’utente può vedere e con cui può interagire. Il backend, invece, è la parte dell’iceberg che si trova sott’acqua. È la logica sottostante che dà energia al business.

Frontend

Il frontend è l’interfaccia grafica di un sito web, di un’applicazione mobile o di qualsiasi altro tipo di client con cui l’utente può interagire. Il frontend comprende tutti gli aspetti visivi di un’applicazione, tra cui il design, i menu, i testi, le immagini, i video, e così via. Nella maggior parte dei progetti, rappresenta circa il 20% dell’impegno totale e non è ripetitivo.

Gli sviluppatori di frontend devono occuparsi di:

• Design reattivo
• Prestazioni dell’app
• Compatibilità cross-browser
• Problemi di accessibilità
• Ottimizzazione SEO

I frontend web sono solitamente implementati con strumenti come HTML, CSS, JavaScript e WebAssembly. Le applicazioni native Android sono scritte in Java/Kotlin, mentre quelle native iOS utilizzano Objective-C e Swift.

Negli ultimi anni, molti sviluppatori di frontend hanno adattato strumenti come React Native, Vue e Svelte Native per semplificare ulteriormente il processo di sviluppo e far funzionare lo stesso codice base su piattaforme diverse.

I frontend possono essere “distribuiti” su servizi come Google Play, App Store, Vercel, Netlify e altri ancora.

Backend

Lo sviluppo backend o lato server consiste nello sviluppo del livello di accesso ai dati. Il backend è la connessione tra il database e il frontend. La maggior parte dei backend fornisce un’interfaccia di livello applicativo (API), che un frontend può utilizzare per recuperare e memorizzare i dati.

I dati vengono solitamente scambiati in formato JSON o GraphQL. Un backend rappresenta di solito circa l’80% del lavoro ed è ripetitivo. Ad esempio, quasi tutti i progetti richiedono autenticazione, autorizzazione, gestione di database, e così via.

Gli sviluppatori di backend si occupano di:

• Gestione del database
• Logica aziendale dell’applicazione
• Scalabilità, alta disponibilità
• Problemi di sicurezza e backup

Gli sviluppatori di backend di solito lavorano con linguaggi di programmazione come Python, JavaScript (Node.js), Ruby, C#, Java e Go. Attualmente, l’architettura di backend più diffusa è Model-View-Controller (MVC), adottata da molti framework web come Django e Laravel.

Il componente più importante di un backend è il suo database. Esistono diversi tipi di database, che possiamo suddividere in tre categorie generali:

• Database SQL
• Database NoSQL
• Database multi-paradigm

Ognuno di questi ha pro e contro che vanno presi in considerazione quando si inizia un progetto.

Un backend può essere distribuito su diverse piattaforme in base al livello di astrazione desiderato. Ad esempio, è possibile utilizzare il proprio server, IaaS (AWS, GCE, Azure), PaaS (Heroku, Digital Ocean App Service) o BaaS (Back4app, Firebase, AWS Amplify).

Continuate a leggere per saperne di più sullo sviluppo di backend per applicazioni mobili.

Cos’è il backend di un’applicazione mobile?

Il backend di un’applicazione mobile è la parte dell’applicazione eseguita su un server, e non sul dispositivo stesso. Il backend fornisce le funzionalità di cui l’applicazione ha bisogno per archiviare e gestire i dati, autenticare gli utenti, elaborare e analizzare i dati e comunicare con altri sistemi o servizi.

Un backend può assumere diverse forme, ad esempio quella di un server in esecuzione su un servizio cloud, un database o un’API. Fornisce l’infrastruttura e gli strumenti necessari al corretto funzionamento dell’applicazione e consente all’applicazione di offrire un’esperienza utente ricca e coinvolgente.

Quali funzioni fornisce un backend mobile?

Un backend per un’applicazione mobile di solito fornisce le seguenti funzionalità:

• Archiviazione e gestione dei dati
• Elaborazione e analisi dei dati
• Autenticazione e autorizzazione
• Sincronizzazione tra più dispositivi
• Capacità di integrarsi con altri sistemi e servizi
• Gestione delle attività lato server
• Analisi e monitoraggio
• Notifiche push

Un’applicazione mobile ha bisogno di un backend?

In breve: se l’applicazione funziona localmente (senza connessione a Internet), di solito non è necessario un backend, ma questo non significa che l’applicazione non possa trarre beneficio da un backend.

Per capire meglio questa risposta, diamo un’occhiata ad alcune delle applicazioni che utilizziamo nella vita quotidiana.

Applicazioni che non hanno bisogno di un backend:

• Calcolatrice
• Calendario e orologio
• Fotocamera e galleria
• Registratore vocale
• Giochi single-player

App che hanno bisogno di un backend:

• Applicazioni di e-commerce: è necessario un backend per tenere traccia dell’inventario, elaborare gli ordini, ecc.
• Applicazioni per i trasporti – un backend consente l’elaborazione dei biglietti, le informazioni sui ritardi, ecc.
• Applicazioni di messaggistica: un backend è utilizzato per trasferire messaggi da un dispositivo all’altro.
• Applicazioni per il meteo – è necessario un backend per recuperare le informazioni meteo attuali.

Pensiamo ora a come un backend potrebbe migliorare le applicazioni sopra elencate:

• Calcolatrice: potrebbe utilizzare un backend per scaricare calcoli complessi su un server remoto.
• Calendario e orologio: potrebbero memorizzare gli eventi in un database e sincronizzarli tra i dispositivi.
• Fotocamera – potrebbe utilizzare un servizio backend per correggere distorsioni, illuminazione, ecc.
• Registratore vocale: potrebbe utilizzare un servizio backend per eliminare il rumore di sottofondo.
• Giochi single-player: potrebbe memorizzare i punteggi degli utenti in un database e mostrare una classifica.

Grazie ai grandi vantaggi offerti dai backend, quasi tutte le applicazioni mobili ne hanno uno. Oltre a memorizzare i dati, il backend consente alle applicazioni mobili di raccogliere analisi, inviare notifiche push, monitorare le app, raccogliere segnalazioni di crash e altro ancora. Se volete avere successo, molto probabilmente avrete bisogno di un backend.

Quali sono i tipi di backend?

A seconda del tipo di applicazione, si possono scegliere diversi tipi di backend. In generale, possiamo dividerli in tre gruppi in base al loro livello di astrazione:

1. Software as a Service (SaaS) o servizi di terzi
2. Mobile Backend as a Service (MBaaS)
3. Backend personalizzati

Vediamoli uno per uno.

Software as a Service (SaaS) o servizi di terzi

Il Software as a service (SaaS) è un modello di fornitura di software in cui un’applicazione software è ospitata da un fornitore di terze parti e resa disponibile ai clienti su Internet.

Le soluzioni SaaS richiedono in genere ai clienti il pagamento di un abbonamento mensile o annuale. Questo tipo di backend è il più facile da usare e consente di ottenere il backend in pochi clic.

Lo svantaggio di questo tipo di backend è che molto probabilmente non troverete un SaaS che soddisfi tutti i requisiti del vostro progetto. Per costruire un backend concreto dovrete probabilmente combinare più soluzioni SaaS.

Alcuni esempi di SaaS sono:

• WordPress (Sistema di gestione dei contenuti)
• Mailchimp (Software di gestione ed email marketing)
• Salesforce (Software di gestione delle relazioni con i clienti)
• Shopify (Piattaforma e-commerce)
• Dropbox (Hosting di file)

Mobile Backend as a Service (MBaaS)

Backend as a Service (BaaS) è una piattaforma che automatizza il lato backend dello sviluppo e si occupa dell’infrastruttura cloud.

Inoltre, fornisce funzionalità come la gestione degli utenti, le notifiche e-mail, le notifiche push, le funzioni di codice cloud, le integrazioni con i social media, l’archiviazione dei file e i pagamenti.

In questo modo gli sviluppatori possono concentrarsi sul core business e sulla costruzione del frontend senza preoccuparsi del backend e dell’infrastruttura sottostante. Il frontend viene solitamente sviluppato tramite API e SDK specializzati offerti dal fornitore di BaaS. Questo rende le applicazioni meno complesse e più facili da mantenere.

I vantaggi dell’utilizzo di un Backend as a Service includono una maggiore velocità di sviluppo, costi di progettazione più bassi e la possibilità di concentrarsi sul core business.

Ecco alcuni esempi di BaaS:

• Back4app
• Firebase
• AWS Amplify
• Apple Cloudkit

Volete saperne di più su BaaS e MBaas? Date un’occhiata all’articolo What is BaaS?

Backend personalizzato

Un backend personalizzato è l’opzione più efficace e flessibile. Offre un controllo totale e consente di implementare funzionalità che non possono essere realizzate con una soluzione SaaS o MBaaS.

Il suo maggiore svantaggio è rappresentato dai costi e dai tempi di realizzazione. Utilizzando questo approccio, inoltre, sarete completamente responsabili delle prestazioni e della sicurezza del vostro backend.

La costruzione di un backend personalizzato richiede solitamente mesi e la presenza di uno sviluppatore di backend esperto o addirittura di un team di sviluppatori di backend.

Framework popolari per la costruzione di backend personalizzati:

• Django
• Laravel
• Express.js
• Ruby on Rails
• Spring Boot

Per ulteriori informazioni sui framework per il backend, date un’occhiata all’articolo Top 10 backend frameworks.

Quanto costa realizzare il backend di un’applicazione mobile?

Non esiste una formula semplice per calcolare il costo del backend di un’applicazione mobile. Il costo varia a seconda della complessità dell’applicazione, del numero di funzionalità, della scalabilità, delle prestazioni, e così via.

Costo per SaaS

Il SaaS è in genere l’opzione più economica. I prodotti SaaS di solito seguono un modello di prezzo semplice, con canoni di abbonamento mensili o annuali. Alcuni fornitori SaaS offrono anche diversi livelli di prezzo a seconda delle dimensioni dell’azienda.

Costo per MBaaS

Costruire un backend con MBaaS è davvero economico rispetto a un backend personalizzato. Vi permette di ridurre notevolmente i costi di sviluppo e di non dovervi preoccupare dell’infrastruttura o della ricerca di un team di ingegneri specializzati nel backend. In questo modo potrete risparmiare un sacco di soldi!

La maggior parte dei fornitori di MBaaS prevede diversi livelli di prezzo a seconda delle dimensioni dell’applicazione. Se utilizzate MBaaS, potete aspettarvi di pagare da 15 a 500 dollari al mese.

Costo per backend personalizzato

Lo sviluppo di un backend personalizzato è l’opzione più costosa. Scegliendola, dovrete formare un team di sviluppatori qualificati e occuparvi dell’infrastruttura del vostro backend.

I prezzi per la costruzione di un backend personalizzato variano generalmente da qualche migliaio di dollari a decine di migliaia di dollari, a seconda dei requisiti del progetto.

Essendo l’implementazione di un backend personalizzato un compito difficile, le aziende di solito lo affidano a società specializzate nello sviluppo di software.

Come costruire un backend per un’applicazione mobile utilizzando MBaaS?

In questa sezione del tutorial, vedremo come sviluppare un backend per un’applicazione mobile utilizzando Back4app.

Cos’è Back4app?

Back4app è una delle migliori soluzioni open-source di Backend as a Service (BaaS) presenti sul mercato. Offre una vasta gamma di funzionalità e vantaggi ai suoi utenti, consentendo agli sviluppatori di creare applicazioni web e mobili in tempi rapidi.

Utilizzando Back4app potrete concentrarvi sul core business invece di preoccuparvi del backend o dell’infrastruttura sottostante.

Questa soluzione è dotata di una dashboard ricca di funzionalità e facile da usare e di una interfaccia a linea di comando (CLI). Fornisce inoltre SDK per tutti i vostri strumenti preferiti come Flutter, React Native, Node.js, Angular, Android, iOS e altri ancora!

Le caratteristiche principali di Back4app includono:

• Database simile a un foglio di calcolo
• API REST e GraphQL
• Query live
• Autenticazione (compresa l’autenticazione tramite social)
• Hosting scalabile
• Notifiche push e via e-mail

Per ulteriori informazioni sulle loro caratteristiche, visita il sito Back4app.

Back4app segue un modello di prezzo semplice e lineare che si adatta ad applicazioni di qualsiasi dimensione. Offre un generoso piano gratuito (non è richiesta la carta di credito), ottimo per la creazione di prototipi e per testare la piattaforma. Include:

• 25k richieste
• 250 MB di archiviazione dati
• 1 GB di trasferimento
• 1 GB di archiviazione file

Per ulteriori informazioni sui prezzi di Back4app, date un’occhiata alla sezione Prezzi.

Introduzione al progetto

Costruiremo un backend per una semplice app di notizie. L’applicazione consentirà ai redattori di creare, aggiornare e cancellare articoli. Per rendere la gestione il più semplice possibile, abiliteremo la Admin App di Back4app.

Ci occuperemo della sicurezza del backend e mostreremo come utilizzare l’API REST. Il backend sarà costruito con una quantità minima di codice.

Prerequisites:

• Conoscenza base del Backend as a Service (BaaS)
• Conoscenza base dei database (e delle relazioni tra i modelli)
• Conoscenza base delle richieste e delle risposte HTTP
• Conoscenza della sintassi JSON

Objectives:

Alla fine di questo tutorial sarete in grado di:

• Costruire e distribuire un semplice backend su Back4app
• Strutturare un database personale
• Comprendere le basi della Parse Platform Security
• Eseguire operazioni CRUD tramite l’API REST

Create App

Per procedere con i passaggi seguenti è necessario disporre di un account Back4app. Se lo avete già, fate il log in, altrimenti create un account.

Per lavorare con Back4app è necessario creare un’applicazione. Accedendo alla vostra dashboard, vedrete l’elenco delle vostre app. Cliccate su “Crea una nuova app” per crearne una nuova.

Dategli un nome personalizzato e poi cliccate su “Continua”.

Back4app impiegherà qualche istante per preparare tutto il necessario per la vostra applicazione, come il database, il layer dell’applicazione, lo scaling, i backup e la sicurezza.

Una volta che l’applicazione è pronta, sarete reindirizzati alla dashboard della vostra applicazione.

Database

In questa sezione del tutorial, creeremo tutti i modelli di database necessari.

Come accennato nell’introduzione del progetto, costruiremo una semplice applicazione di notizie. Il nostro database sarà composto dai seguenti modelli:

• Article rappresenta un articolo.
• ArticleCategory rappresenta una categoria di articoli (ad esempio, sport, intrattenimento). Un articolo può appartenere a una sola categoria.
• ArticleTag rappresenta l’hashtag di un articolo (es., cosmetici, salute, bellezza). Un articolo può avere più hashtag.

Questa struttura di database ci permetterà poi di filtrare gli articoli in base alle categorie o ai tag. Disegniamo un diagramma delle relazioni tra entità (entity relationship diagram, ERD) per capire meglio le relazioni tra i modelli:

Ora, creiamo effettivamente i modelli.

Iniziamo con la creazione del modello ArticleCategory. In alto a sinistra della schermata, clicchiamo su “Crea una classe”, chiamiamola ArticleCategory e aggiungiamo i seguenti campi:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Poi, creiamo un’altra classe, denominata  ArticleTag con i seguenti dettagli:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Infine, creiamo un’altra classe, denominata  Article con i seguenti campi:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | title       | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| String                      | content     | <leave blank> | yes      |
+-----------------------------+-------------+--------------+-----------+
| Pointer -> ArticleCategory  | category    | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ArticleTag      | tags        | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Questo è tutto per quanto riguarda l’architettura del database. Ora aggiungiamo alcuni campioni di dati.

Per rendere le cose un po’ più semplici, ho generato alcuni dati che potete importare. Per importare un set di dati, selezionate la classe sul lato sinistro dello schermo e poi cliccate sui tre punti sul lato destro dello schermo. Selezionate “Import” > “Class Data” e selezionate il file appropriato.

Per scaricare i set di dati JSON, visitate la repo GitHub di back4app-mobile, cliccate su “Code” e poi su “Download ZIP”.

Importate i file JSON nel seguente ordine:

1. User
2. ArticleCategory
3. ArticleTag
4. Article

Pannello di amministrazione

Per rendere l’amministrazione un po’ più semplice, attiveremo l’Admin App. L’Admin App è uno strumento basato su un browser web progettato per gestire i dati dell’applicazione utilizzando un’interfaccia utente non tecnica.

Accedete alla dashboard dell’applicazione, cliccate su “More” > “Admin App” e quindi sul pulsante “Enable Admin App”.

Scegliete un nome utente e una password. Io sceglierò:

Username: admin
Password: complexpassword123

Quindi scegliete un nome di dominio che volete usare per accedere al vostro pannello di amministrazione. Io sceglierò:

mobile-backend.admin.back4app.com

Bene, ora potete accedere alla dashboard di amministrazione del dominio selezionato.

Per saperne di più su Back4app Admin App, date un’occhiata alla sezione doc ufficiali.

Rendere sicura l’app

Per rendere sicura la nostra applicazione dobbiamo eseguire le seguenti operazioni:

1. Disabilitare la creazione di classi client.
2. Modificare le autorizzazioni a livello di classe (CLP) del modello User.
3. Modificare le CLP per ogni modello creato.

Disabilitare la creazione di classi client 

Per disabilitare la creazione di classi client, andate in “App Settings” > “Server Settings” > “Core Settings” > “Edit”, scorrete fino in fondo alla pagina e deselezionate “Allow Client Class Creation”.

Modificare le CLP per il modello User

Selezionate il vostro modello User nella scheda “Database” e cliccate sui tre punti sul lato destro dello schermo > “Security” > “Class Level Permissions”. Quindi cliccate sull’icona a forma di ingranaggio e impostatela su “Advanced”. Togliete la spunta a tutto tranne che a  Get e Create in questo modo:

Modificare le CLP per ogni modello creato

Procedete in modo simile per tutti i modelli personalizzati  (Article, ArticleCategory, e ArticleTag). Questa volta disabilitate tutto, tranne t Read e Find per il gruppo Public, in questo modo:

In questo modo gli utenti non autenticati potranno solo trovare e leggere gli articoli.

Per ulteriori informazioni sulla sicurezza, consultate Parse Security.

Testare l’API

In questa sezione del tutorial, testeremo la nostra API utilizzando la Console API integrata.

Per aprire la Console API REST, navigare nella dashboard della propria applicazione. Selezionare “Console” nella sezione “API” e poi “REST”.

A causa delle nostre ACL/CLP, assicuratevi di spuntare “Use Master Key?” affinché le richieste abbiano successo.

Recupero

Gli oggetti possono essere recuperati con il tipo di richiesta GET . Per l’endpoint utilizzate  classes/<your_class> ad esempio  classes/Article e cliccate sul pulsante “Send Query” in fondo alla pagina.

La risposta sarà simile a questa:

{
    "results": [
                {
            "objectId": "oRwkdx7KgX",
            "title": "Voting 2022 has ended!",
            "description": "The voting for year 2022 has ended, the new major is...",
            "content": "Lorem ipsum dolor sit amet...",
            "category": {
                "__type": "Pointer",
                "className": "ArticleCategory",
                "objectId": "FYxzrBlCBC"
            },
            "author": {
                "__type": "Pointer",
                "className": "_User",
                "objectId": "UZ76K07znv"
            },
            "createdAt": "2022-12-13T09:09:04.845Z",
            "updatedAt": "2022-12-13T09:09:13.297Z",
            "tags": {
                "__type": "Relation",
                "className": "ArticleTag"
            }
        },
        ... more results ...
    ]
}

Se volete recuperare un risultato specifico o filtrare il set di query, consultate i doc.

Create

Per creare un’istanza di modello, selezionate la richiesta POST e inviatela a  classes/<your_class>, ad esempio . classes/Article. Con le richieste  POST è necessario fornire parametri di query. Ad esempio:

{
   "title": "Another article",
   "content": "This is another test article added via the API",
   "category": {
      "__type": "Pointer",
      "className" :"ArticleCategory",
      "objectId": "pPGdxPAxQA"
   },
   "author": {
      "__type": "Pointer",
      "className": "_User",
      "objectId": "LFAf3yD8w0"
   }
}

Risposta:

{
    "objectId": "yAbmJ0sRZT",
    "createdAt": "2022-12-12T17:18:32.922Z"
}

Update

Per aggiornare un modello, selezionare il tipo di richiesta PUT e inviarla a classes/<your_class>/<object_id>, ad esempio . classes/Article/oRwkdx7KgX. Dovrete fornire i parametri della query contenenti i dati che desiderate modificare:

{"description": "Back4app is cool!"}

Risposta:

{
    "updatedAt": "2022-12-12T17:31:23.459Z"
}

Delete

Per cancellare un’istanza di modello, selezionare il tipo di richiesta ELIMINA e inviarla a classes/<your_class>/<object_id>, ad esempio . classes/Article/oRwkdx7KgX.

Se la richiesta è andata a buon fine, verrà restituito un corpo vuoto.

Per saperne di più sulle richieste REST con Back4app, date un’occhiata alla sezione API reference.

Passi successivi

Il nostro backend per un’applicazione mobile è ora più o meno completo. Per collegarlo alla vostra applicazione mobile, dovrete:

1. Ottenere il vostro Application ID e la vostra  Client key da  “App Settings” > “Security & Keys”.
2. Installare il ParseJS SDK appropriato (in base alla piattaforma).
3. Utilizzare l’SDK per connettersi a Back4app utilizzando le proprie credenziali.
4. Utilizzare l’SDK per inviare richieste.

Per istruzioni dettagliate consultare i nostri doc:

• Flutter Quickstart
• React Native Quickstart
• Android Quickstart
• iOS Quickstart

Conclusione

I termini frontend e backend si riferiscono alla separazione dei problemi tra il livello di presentazione e il livello di accesso ai dati.

Al giorno d’oggi quasi tutte le applicazioni mobili hanno un backend proprio, per via di tutti i vantaggi offerti. I backend consentono alle applicazioni mobili di raccogliere dati analitici, inviare notifiche push, monitorare le applicazioni, raccogliere segnalazioni di crash e altro ancora.

Esistono diversi modi per costruire un backend. È possibile:

• Combinare più prodotti SaaS
• Utilizzare Mobile Backend as a Service (MBaaS)
• Costruire un backend personalizzato

L’utilizzo di MBaaS è un’ottima opzione, in quanto è davvero economico rispetto a un backend personalizzato, pur offrendo una grande flessibilità. Back4app è uno dei migliori fornitori di MBaaS che permette di costruire un backend in pochi giorni o addirittura in poche ore.

FAQ