Che cos’è un’infrastruttura backend?
La scelta della corretta infrastruttura di backend è fondamentale quando si progetta il backend. Può influire sulle prestazioni, sulla flessibilità e sulla manutenibilità del backend, per citarne alcune.
In questo articolo spiegheremo cos’è l’infrastruttura di backend, esploreremo i diversi tipi di infrastrutture di backend e discuteremo i fattori essenziali da tenere presenti al momento della scelta.
Inoltre, vedremo come creare un’infrastruttura backend utilizzando Back4app.
Contents
Obiettivi
Alla fine di questo articolo, sarete in grado di:
- Spiegare cos’è l’infrastruttura di backend
- Discutere i diversi tipi di infrastrutture di backend (tra cui IaaS, PaaS e BaaS).
- Scegliete l’infrastruttura di backend adatta al vostro progetto
- Costruire il proprio backend con Back4app
Che cos’è un’infrastruttura backend?
L’infrastruttura di backend è la combinazione di componenti software e hardware che supportano un sistema di backend. Include server, container, componenti di rete, firewall e altre risorse.
L’infrastruttura di backend è responsabile dell’alta disponibilità, della scalabilità, del bilanciamento del carico, della sicurezza, del routing e così via. L’infrastruttura di backend deve essere progettata in modo da offrire un’esperienza utente senza soluzione di continuità.
Cosa considerare quando si sceglie un’infrastruttura backend?
Discutiamo i fattori essenziali da considerare quando si sceglie un’infrastruttura di backend.
Velocità
La velocità è una delle caratteristiche fondamentali dell’infrastruttura di backend. Gli utenti vogliono che l’applicazione funzioni nel modo più fluido possibile. Per questo motivo, è necessario ottimizzare la comunicazione tra client e backend.
Per attenuare la percezione dei ritardi di comunicazione, si possono usare alcuni trucchi intelligenti. Ad esempio, è possibile implementare nell’interfaccia utente schermate scheletriche, barre di caricamento e visualizzare suggerimenti e trucchi.
Anche la velocità è uno dei fattori più critici della SEO.
Flessibilità
La flessibilità si riferisce ai linguaggi di programmazione, ai framework e alle altre tecnologie (ad esempio, i database) supportati dall’infrastruttura di backend. Quando scegliete un’infrastruttura di backend, assicuratevi di scegliere qualcosa che supporti una varietà di tecnologie.
Scalabilità
Dovete considerare la scalabilità fin dal momento in cui iniziate a costruire la vostra applicazione. Pensate a come verrà utilizzata la vostra applicazione. Avrete un numero costante di utenti, o a volte gli utenti aumenteranno?
L’infrastruttura di backend deve essere costruita in modo da poter gestire carichi di lavoro estremi. Per ridurre al minimo le spese per i server, le istanze delle applicazioni devono essere create e distrutte al volo.
Manutenibilità
Lo sviluppo e la pubblicazione dell’applicazione rappresentano solo l’80% del lavoro. In seguito, dovrete investire molto tempo nella manutenzione dell’applicazione. Aggiornare il software del server e distribuire le patch di sicurezza deve essere il più semplice possibile.
Optate per un’infrastruttura di backend con un sistema CI/CD integrato o implementate il vostro.
Requisiti DevOps
Alcuni tipi di infrastrutture di backend sono più difficili da utilizzare. Scegliete l’infrastruttura di backend che avete il tempo e le risorse per gestire. Se decidete di utilizzare un’infrastruttura di backend di livello inferiore, come IaaS, avrete bisogno di un team DevOps specializzato per gestirla.
Sicurezza
Siete pienamente responsabili della sicurezza dei dati dei vostri utenti. Con un numero crescente di attacchi informatici, dovete assicurarvi che la vostra infrastruttura di backend segua gli standard di sicurezza più recenti.
Utilizzate password forti generate automaticamente, impostate il firewall, non eseguite software non attendibili sui vostri server, eseguite controlli di sicurezza regolari, eccetera.
Tipi di infrastruttura backend
Potete utilizzare i vostri server (la cosiddetta infrastruttura tradizionale) o sfruttare l’infrastruttura cloud per distribuire il vostro backend.
Nell’ultimo decennio, molte aziende si sono orientate verso modelli cloud perché consentono di risparmiare tempo e denaro.
Analizziamo alcuni dei più popolari.
Infrastruttura come servizio o IaaS
L’Infrastruttura come servizio (IaaS) è il modello di cloud computing meno astratto. In questo modello, il fornitore del cloud fornisce risorse informatiche in un ambiente virtualizzato, come server, storage, sistemi operativi e componenti di rete.
L’IaaS esiste dal 2010 ed è ancora il modello di cloud computing più diffuso. I suoi vantaggi sono la grande scalabilità, il controllo di alto livello e l’efficienza dei prezzi. Per contro, i contro sono la gestione complessa e i costi di manutenzione più elevati rispetto ad altri modelli di cloud.
Alcuni dei più noti fornitori di IaaS sono:
Piattaforma come servizio o PaaS
Platform as a Service (PaaS) è un modello di cloud computing che offre un ambiente di sviluppo, gestione e distribuzione delle applicazioni facile da usare. Include diversi strumenti integrati per lo sviluppo di applicazioni, che rendono facile l’avvio della vostra applicazione.
Il PaaS semplifica la gestione dell’infrastruttura, garantendo un ingresso più rapido nel mercato, maggiore sicurezza, risparmi sui costi, scalabilità, alta disponibilità e riduzione della codifica. D’altro canto, può vincolare l’utente alle capacità del fornitore, porre rischi di vendor lock-in e limitare la flessibilità e il controllo.
Esempi di soluzioni PaaS sono
Backend come servizio o BaaS
Backend as a Service (BaaS) automatizza lo sviluppo lato server e la gestione dell’infrastruttura cloud. Offre database in tempo reale, gestione degli utenti, autenticazione, notifiche, integrazioni con i social media e così via.
BaaS libera gli sviluppatori dalle preoccupazioni del backend, consentendo loro di concentrarsi sul frontend e sul core business. Il BaaS combina i vantaggi dello IaaS e del PaaS con l’astrazione del backend, con conseguente accelerazione del time-to-market e riduzione dei costi. Gli aspetti negativi sono la mancanza di controllo, il rischio di un vendor lock-in e i costi relativamente elevati.
Le mie piattaforme BaaS preferite sono:
Contenitori come servizio o CaaS
Containers as a Service (CaaS) è un modello di cloud computing per caricare, costruire, scalare e gestire container. CaaS di solito include un runtime per container, un registro dei container, funzionalità di scalatura automatica, sistema CI/CD integrato, bilanciamento del carico e altro ancora!
CaaS semplifica la gestione dei container, eliminando le preoccupazioni relative all’infrastruttura sottostante. Incoraggia lo sviluppo agile, facilita l’architettura a microservizi e accelera la creazione di applicazioni altamente scalabili.
Le piattaforme CaaS includono:
Come creare un’infrastruttura backend?
In questa parte dell’articolo, creeremo un’infrastruttura backend utilizzando Back4app.
Che cos’è Back4app?
Back4app è un’eccezionale piattaforma Backend as a Service (BaaS). Consente di creare rapidamente backend per applicazioni web e mobili.
La piattaforma è costruita utilizzando tecnologie open source e dispone di numerose funzionalità. Le sue caratteristiche includono database simili a fogli di calcolo, archiviazione di file, gestione degli utenti, autenticazione, API generate automaticamente, notifiche e altro ancora!
Back4app può aiutarvi ad accelerare significativamente il vostro time to market. Sfruttandola, potrete concentrarvi sul cuore della vostra attività invece di preoccuparvi del backend o dell’infrastruttura sottostante.
Non avrete bisogno di ingegneri DevOps specializzati e i costi di manutenzione saranno inferiori.
L’aspetto migliore di Back4app è che è dotato di un livello gratuito. Il livello gratuito è eccellente per testare la piattaforma o per ospitare progetti minori. Se la vostra applicazione avrà successo, potrete passare al livello premium.
Per saperne di più su Back4app, consultare Cos’è Back4app?
Panoramica del progetto
Per mostrare come creare un backend, costruiremo un semplice servizio di backend per il commercio elettronico. Il backend ci permetterà di gestire prodotti, categorie e ordini.
Il diagramma ER del nostro progetto avrà questo aspetto:
Realizzeremo il backend con una quantità minima di codice e dimostreremo come può essere utilizzato sul lato client (tramite SDK, API REST e API GraphQL).
Creare un’applicazione
Per seguirci, è necessario un account Back4app. Ne avete bisogno? Iscrivetevi oggi stesso!
Dopo aver effettuato l’accesso al vostro account Back4app, vedrete l’elenco delle vostre app. Cliccate sul pulsante “Build app” per avviare il processo di creazione dell’app.
Quindi, selezionare “BaaS” perché stiamo configurando un backend.
Scegliete un nome per l’applicazione, scegliete “NoSQL” e create l’applicazione.
Back4app richiede un po’ di tempo per configurare tutto. Gestirà il livello applicativo, il database, i backup, la scalabilità e altro ancora.
Una volta costruita l’app, si accede al database in tempo reale dell’applicazione.
Impostazione del database
Ora che abbiamo creato la nostra applicazione, occupiamoci del database.
Per prima cosa dobbiamo creare una classe per memorizzare i dati nel database. Le classi possono essere considerate come tabelle (terminologia SQL) o modelli (terminologia ORM). Ogni classe ha i seguenti quattro campi per impostazione predefinita:
+-------------+-------------+------------------------------------------+
| Type | Name | Description |
+-------------+-------------+------------------------------------------+
| String | objectId | Object's unique identifier |
+-------------+-------------+------------------------------------------+
| Date | updatedAt | Date time of the last update |
+-------------+-------------+------------------------------------------+
| Date | createdAt | Date time of creation |
+-------------+-------------+------------------------------------------+
| ACL | ACL | Access Control List |
+-------------+-------------+------------------------------------------+Come indicato nella panoramica del progetto, il nostro progetto avrà tre classi. Creare la prima facendo clic sul pulsante “Crea classe” nella barra laterale. Nominarla ProductCategory:
Aggiungere i seguenti campi:
+-----------------------------+-------------+---------------+----------+
| Type | Name | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String | name | <leave blank> | yes |
+-----------------------------+-------------+---------------+----------+
| String | description | <leave blank> | no |
+-----------------------------+-------------+---------------+----------+Eseguire gli stessi passaggi per la classe Prodotto:
+-----------------------------+-------------+---------------+----------+
| Type | Name | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String | name | <leave blank> | yes |
+-----------------------------+-------------+---------------+----------+
| String | description | <leave blank> | no |
+-----------------------------+-------------+---------------+----------+
| Relation -> ProductCategory | categories | <leave blank> | no |
+-----------------------------+-------------+---------------+----------+
| Number | price | 0 | yes |
+-----------------------------+-------------+---------------+----------+Abbiamo usato il tipo di dato
Relationper gestire la relazione molti-a-molti.
Infine, creare la classe Order:
+-----------------------------+------------+---------------+----------+
| Data type | Name | Default value | Required |
+-----------------------------+------------+---------------+----------+
| Pointer -> Product | product | <leave blank> | yes |
+-----------------------------+------------+---------------+----------+
| String | cFirstName | <leave blank> | yes |
+-----------------------------+------------+---------------+----------+
| String | cLastName | <leave blank> | yes |
+-----------------------------+------------+---------------+----------+
| String | cAddress | <leave blank> | yes |
+-----------------------------+------------+---------------+----------+
| Number | delivered | false | yes |
+-----------------------------+------------+---------------+----------+Abbiamo utilizzato il tipo di dato
Pointerper gestire la relazione uno-a-molti.
Una volta terminato, si dovrebbero vedere le classi nella barra laterale.
Popolare il database
Procediamo con il popolamento del database.
Iniziate creando alcune categorie di prodotti, prodotti e ordini (in quest’ordine). Se siete a corto di idee, non esitate a importare questo dispositivo.
Per importare un file JSON, utilizzare l’opzione “Altro > Importazione > Dati della classe > Seleziona file”. Assicurarsi di importare i file JSON nel seguente ordine:
- ProdottoCategoria.json
- Prodotto.json
- _Join꞉categories꞉Product.json
- Ordine.json
Al termine, si dovrebbero avere alcuni prodotti, categorie e ordini nel database. Questo passo è necessario perché avremo bisogno di alcuni dati per testare il backend nella fase successiva.
Proteggere il database
Per impostazione predefinita, le classi del database vengono create in “modalità protetta”. In modalità protetta, l’unico modo per interagire e gestire gli oggetti è utilizzare la chiave master. Questo non è ottimale, perché non è possibile recuperare o gestire gli oggetti dal lato client.
Per poterlo fare, dobbiamo allentare alcune restrizioni. Back4app/Parse è dotato di due meccanismi di restrizione:
- Autorizzazioni a livello di classe (CLP)
- Autorizzazioni a livello di accesso (ACL)
Le CLP consentono di applicare restrizioni a livello di classe, mentre le ACL consentono di applicare restrizioni a livello di oggetto. Entrambi i meccanismi possono limitare una classe o un oggetto a un ruolo o a un utente specifico.
Selezionare la classe di prodotto nella barra laterale e fare clic sul testo “Protetto” nella parte superiore dello schermo. Quindi modificare i CLP:
Eseguire gli stessi passaggi per il modello ProductCategory.
Quindi aggiornare i CLP per la classe Ordine:
Prestare attenzione all’immagine. Qui si abilita anche l’autorizzazione a
creare.
I nuovi CLP consentiranno agli utenti non autenticati di recuperare, interrogare e contare i prodottie le categorie di prodotti, ma non di modificarli. Lo stesso vale per la classe Order, ma in questo caso gli utenti possono anche creare nuovi ordini.
Per saperne di più, consultate il nostro articolo sulla sicurezza del server Parse.
App amministrativa
Al momento, l’unico modo per gestire gli oggetti nel database è utilizzare la vista del database. Sebbene funzioni per gli sviluppatori, non è intuitivo per gli utenti non tecnici. Inoltre, dà agli utenti un controllo eccessivo ed è soggetto a errori umani.
Fortunatamente, Back4app consente di attivare facilmente la funzionalità “Admin App”. Admin App è un pannello di amministrazione facile da usare e adattato alle vostre classi di database.
Per attivarla, spostarsi prima su “Altro > Admin App” nella barra laterale. Quindi fare clic su “Abilita”:
Back4app vi chiederà di scegliere un nome utente, una password e un sottodominio. Ho deciso di scegliere il seguente:
user: root
pass: complexpassword123
subdomain: https://binfra.admin.back4app.com/Ottimo, non dovete fare altro.
È possibile accedere al pannello di amministrazione facendo clic su “Admin App URL”. Facendo clic su di esso, si aprirà una nuova finestra del browser e verrà richiesto di inserire le proprie credenziali di amministrazione. Una volta effettuato l’accesso, è possibile creare, aggiornare e cancellare oggetti.
Provate a giocare con il cruscotto per abituarvi.
Codice Cloud
Back4app consente di eseguire codice JavaScript personalizzato tramite il cosiddetto Cloud Code. Con Cloud Code è possibile definire funzioni che possono essere attivate da Parse, da richieste HTTP o eseguite periodicamente. Inoltre, Cloud Code può essere utilizzato per costruire applicazioni web utilizzando Express.
Funzione Codice Cloud
Supponiamo di volere una funzione di Cloud Code che calcoli le vendite correnti.
Per prima cosa, spostatevi su “Cloud Code > Function & Web Hosting” nella barra laterale. Si noterà che la vista di Cloud Code è divisa in due parti. A sinistra si può vedere la struttura della directory e a destra il codice.
Quindi, aprire cloud/main.js e incollare il seguente codice:
// cloud/main.js
Parse.Cloud.define("calculateSales", async (request) => {
const orderClass = Parse.Object.extend("Order");
const orderQuery = new Parse.Query(orderClass);
let sales = 0;
try {
const orders = await orderQuery.find();
for (var i = 0; i < orders.length; i++) {
let order = orders[i];
let productId = order.get("product")["id"];
const productClass = Parse.Object.extend("Product");
const productQuery = new Parse.Query(productClass);
const product = await productQuery.get(productId);
sales += product.get("price");
}
return {
sales: sales,
};
} catch (error) {
console.error("Error calculating the sales: " + error.message);
return {
sales: 0,
}
}
});
Parse.Cloud.job("printSales", async (request, status) => {
try {
const result = await Parse.Cloud.run("calculateSales");
console.log("Sales: " + result.sales + "$");
} catch (error) {
console.error("Error calculating the sales: " + error.message);
}
});- Abbiamo definito una funzione di Cloud Code chiamata
calculateSales(). La funzione esegue un ciclo di tutti gli ordini, recupera i prodotti corrispondenti e ne somma i prezzi. - Abbiamo definito un Job di Cloud Code chiamato
printSales(), che ci consente di eseguire la funzione dalla dashboard di Parse e di programmarla periodicamente.
Infine, fare clic su “Deploy” per distribuire il Cloud Code.
Assicurarsi che il lavoro funzioni navigando su “Cloud Code > Jobs” nella barra laterale ed eseguendo il lavoro printSales(). Se tutto funziona bene, si dovrebbe vedere un messaggio che dice, ad esempio, Sales: 1440$ quando si controllano i log.
Pianificazione del codice nel cloud
Per programmare il lavoro, è necessario andare su “Impostazioni app > Impostazioni server” nella barra laterale. Scorrere fino a “Lavori in background”, fare clic su “Pianifica un lavoro” e compilare il modulo.
Per assicurarsi che funzioni, controllare ancora una volta i registri.
Lato cliente
Esistono diversi modi per interagire con il backend basato su Back4app:
- SDK Parse
- API RESTful (generata automaticamente)
- API GraphQL (generata automaticamente)
Come regola generale, si dovrebbe sempre usare Parse SDK se è disponibile per la propria piattaforma. In caso contrario, si può scegliere l’API RESTful o l’API GraphQL. La scelta tra le API dipende dai vostri dati.
Scoprite come utilizzare Parse SDK con vari framework consultando la documentazione.
Tuttavia, testiamo il nostro backend utilizzando la console REST integrata.
Andare su “API > REST” nella barra laterale e provare a interrogare tutti i prodotti compilando il modulo:
Dovreste ottenere una risposta simile:
{
"results": [
{
"objectId": "4ZyHH3X0RQ",
"name": "Fitness Tracker Watch",
"description": "...",
"price": 80,
"createdAt": "2023-10-17T20:03:55.424Z",
"updatedAt": "2023-10-17T20:24:12.322Z",
"categories": {
"__type": "Relation",
"className": "ProductCategory"
}
},
{
"objectId": "cDqlGJzT5U",
"name": "Organic Fruit Basket",
"description": "...",
"price": 40,
"createdAt": "2023-10-17T20:04:10.063Z",
"updatedAt": "2023-10-17T20:24:00.382Z",
"categories": {
"__type": "Relation",
"className": "ProductCategory"
}
},
// ...
}Provate a eseguire le seguenti query:
- Recuperare tutti i prodotti che hanno un prezzo superiore al 50
- Recuperare tutti gli ordini che non sono ancora stati consegnati
- Creare un nuovo prodotto e aggiungervi una categoria
- Cancellare un ordine
Conclusione
In conclusione, ora sapete cos’è l’infrastruttura backend, conoscete i vari tipi di infrastrutture backend e sapete come scegliere l’infrastruttura adatta al vostro progetto.
Inoltre, avete imparato a creare un’infrastruttura backend su Back4app. Vi siete occupati del database, della sicurezza del database, del codice personalizzato, della programmazione dei lavori e del test delle API.
Per una guida alla creazione del lato client di un backend basato su Back4app, consultate i nostri altri articoli:
- Come ospitare frontend e backend?
- Come sviluppare un’app per i social media?
- Come costruire un chatbot utilizzando React?
Le risorse aggiuntive dell’articolo sono disponibili su un repo GitHub.
