Quickstarters
Come costruire un backend per Blazor?

39min
Introduzione
In questo tutorial, imparerai come costruire un backend completo per un'applicazione Blazor 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 (Live Queries) - per creare un backend sicuro, scalabile e robusto che comunica senza problemi con il tuo frontend Blazor.
Sfruttare i robusti servizi backend di Back4app con Blazor, un framework ASP.NET Core per costruire interfacce web interattive utilizzando C#, consente agli sviluppatori di accelerare lo sviluppo del backend.
Che tu stia costruendo un'app Blazor Server o un'app Blazor WebAssembly, l'integrazione senza soluzione di continuità con Back4app può ridurre drasticamente i tempi di sviluppo garantendo al contempo una logica di business di alta qualità lato server.
Alla fine di questo tutorial, avrai costruito una struttura backend sicura su misura per un'applicazione web full stack utilizzando Blazor.
Acquisirai informazioni su come gestire le operazioni sui dati, applicare controlli di sicurezza e implementare funzioni cloud, rendendo la tua applicazione web Blazor robusta e scalabile.
Prerequisiti
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.
Ambiente di sviluppo Blazor di base
Puoi configurarlo installando l'ultima versione del .NET SDK da Microsoft e creando un nuovo progetto Blazor utilizzando modelli come dotnet new blazorserver o dotnet new blazorwasm.
.NET SDK (versione 6 o superiore) installato
Assicurati di avere il .NET SDK per costruire e eseguire app Blazor.
Familiarità con C# e concetti di Blazor
Documentazione ufficiale di Blazor.
Se sei nuovo in Blazor, rivedi la documentazione ufficiale o un tutorial per principianti prima di iniziare.
Assicurati di avere questi prerequisiti prima di iniziare per garantire un'esperienza di tutorial fluida.
Passo 1 – Impostare il Progetto Back4app
Crea un Nuovo Progetto
Il primo passo per costruire il tuo backend Blazor 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, “Blazor-Backend-Tutorial”).
﻿
Questa configurazione garantisce che ogni volta che utilizzi Parse nella tua applicazione Blazor, sia preconfigurato per connettersi alla tua specifica istanza di Back4app.
Completando questo passaggio, hai stabilito una connessione sicura tra il tuo frontend Blazor e il backend di Back4app, aprendo la strada per eseguire operazioni sul database, gestione degli utenti e altro.
Passo 2 – Configurazione del Database
Salvataggio e Query dei Dati
Con il tuo progetto Back4app configurato e il Parse SDK integrato nella tua app Blazor, puoi ora iniziare a salvare e recuperare dati. Il modo più semplice per creare un record è utilizzare la ParseObject classe:
SomeDataService.cs
using Parse;
using System.Threading.Tasks;

public class SomeDataService {
    public async Task<ParseObject> CreateTodoItemAsync(string title, bool isCompleted) {
        var todo = new ParseObject("Todo");
        todo["title"] = title;
        todo["isCompleted"] = isCompleted;

        try {
            await todo.SaveAsync();
            Console.WriteLine("Todo saved successfully: " + todo.ObjectId);
            return todo;
        } catch (Exception ex) {
            Console.WriteLine("Error saving Todo: " + ex.Message);
            return null;
        }
    }

    public async Task<IList<ParseObject>> FetchTodosAsync() {
        var query = new ParseQuery<ParseObject>("Todo");
        try {
            var results = await query.FindAsync();
            Console.WriteLine("Fetched Todo items: " + results.Count);
            return results;
        } catch (Exception ex) {
            Console.WriteLine("Error fetching Todos: " + ex.Message);
            return null;
        }
    }
}
using Parse;
using System.Threading.Tasks;

public class SomeDataService {
    public async Task<ParseObject> CreateTodoItemAsync(string title, bool isCompleted) {
        var todo = new ParseObject("Todo");
        todo["title"] = title;
        todo["isCompleted"] = isCompleted;

        try {
            await todo.SaveAsync();
            Console.WriteLine("Todo saved successfully: " + todo.ObjectId);
            return todo;
        } catch (Exception ex) {
            Console.WriteLine("Error saving Todo: " + ex.Message);
            return null;
        }
    }

    public async Task<IList<ParseObject>> FetchTodosAsync() {
        var query = new ParseQuery<ParseObject>("Todo");
        try {
            var results = await query.FindAsync();
            Console.WriteLine("Fetched Todo items: " + results.Count);
            return results;
        } catch (Exception ex) {
            Console.WriteLine("Error fetching Todos: " + ex.Message);
            return null;
        }
    }
}
﻿
In alternativa, puoi utilizzare gli endpoint API REST di Back4app per le operazioni.
Progettazione dello Schema e Tipi di Dati
Per impostazione predefinita, Parse consente la creazione di schemi al volo, ma puoi anche definire le tue classi e tipi di dati nel dashboard di Back4app per avere maggiore controllo.
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
﻿
Quando interroghi, includi i dati del puntatore:
SomeDataService.cs (continuation)
public async Task<IList<ParseObject>> FetchTodosWithCategoryAsync() {
    var query = new ParseQuery<ParseObject>("Todo").Include("category");
    try {
        var todosWithCategory = await query.FindAsync();
        return todosWithCategory;
    } catch (Exception ex) {
        Console.WriteLine("Error fetching todos with category: " + ex.Message);
        return null;
    }
}
public async Task<IList<ParseObject>> FetchTodosWithCategoryAsync() {
    var query = new ParseQuery<ParseObject>("Todo").Include("category");
    try {
        var todosWithCategory = await query.FindAsync();
        return todosWithCategory;
    } catch (Exception ex) {
        Console.WriteLine("Error fetching todos with category: " + ex.Message);
        return null;
    }
}
﻿
Query in tempo reale
Per aggiornamenti in tempo reale in un'app Blazor Server, considera di utilizzare la connessione SignalR per le Query in tempo reale. Sebbene il Parse .NET SDK supporti le Query in tempo reale, integrarle direttamente all'interno di un'app Blazor potrebbe richiedere una configurazione aggiuntiva con SignalR per la comunicazione in tempo reale.
Abilita le Query in tempo reale nel tuo dashboard Back4app sotto le Impostazioni del server. Assicurati che “Query in tempo reale” sia attivato.
Configura il Client per le Query in tempo reale in .NET se necessario. Tuttavia, per le app Blazor, sfruttare SignalR potrebbe essere più idiomatico per le connessioni lato server.
A causa della complessità di configurare le Query in tempo reale all'interno di Blazor e delle potenziali limitazioni del Parse .NET SDK in Blazor WebAssembly, potrebbe essere necessario implementare un servizio lato server che colleghi le Query in tempo reale di Parse con i client SignalR.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Meccanismo di Sicurezza di Back4app
Back4app prende sul serio la sicurezza fornendo Liste di Controllo degli Accessi (ACL) e Permessi a Livello di Classe (CLP). Queste funzionalità ti consentono di limitare chi può leggere o scrivere dati su base per oggetto o per classe, garantendo che solo gli utenti autorizzati possano modificare i tuoi dati.
﻿
Liste di Controllo degli Accessi (ACL)
Un ACL è applicato a singoli oggetti per determinare quali utenti, ruoli o il pubblico possono eseguire operazioni di lettura/scrittura. Ad esempio:
SomeDataService.cs (ACL example)
public async Task<ParseObject> CreatePrivateTodoAsync(string title, ParseUser ownerUser) {
    var todo = new ParseObject("Todo");
    todo["title"] = title;

    // Create an ACL granting read/write access only to the owner
    var acl = new ParseACL(ownerUser);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    todo.ACL = acl;

    try {
        await todo.SaveAsync();
        return todo;
    } catch (Exception ex) {
        Console.WriteLine("Error saving private todo: " + ex.Message);
        return null;
    }
}
public async Task<ParseObject> CreatePrivateTodoAsync(string title, ParseUser ownerUser) {
    var todo = new ParseObject("Todo");
    todo["title"] = title;

    // Create an ACL granting read/write access only to the owner
    var acl = new ParseACL(ownerUser);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    todo.ACL = acl;

    try {
        await todo.SaveAsync();
        return todo;
    } catch (Exception ex) {
        Console.WriteLine("Error saving private todo: " + ex.Message);
        return null;
    }
}
﻿
Quando salvi l'oggetto, ha un ACL che impedisce a chiunque tranne l'utente specificato di leggerlo o modificarlo.
Permessi a Livello di Classe (CLP)
I CLP governano i permessi predefiniti di un'intera classe, come se la classe sia leggibile o scrivibile pubblicamente, o se solo determinati ruoli possano accedervi.
Vai al tuo Dashboard di Back4app, seleziona la tua app e apri la Database sezione.
Seleziona una classe (ad esempio, “Todo”).
Apri la scheda dei Permessi a Livello di Classe. 
Configura i tuoi predefiniti, come “Richiede Autenticazione” per la lettura o la scrittura, o “Nessun Accesso” per il pubblico.
Questi permessi impostano la base, mentre gli ACL affinano i permessi per singoli oggetti. Un modello di sicurezza robusto combina tipicamente sia i CLP (restrizioni ampie) che gli ACL (restrizioni dettagliate per oggetto). Per ulteriori informazioni, vai a Linee Guida sulla Sicurezza dell'App.﻿
Passo 4 – Scrivere e Distribuire Funzioni Cloud
Il Cloud Code è una funzionalità dell'ambiente Parse Server che consente di eseguire codice JavaScript personalizzato sul lato server - senza la necessità di gestire i propri server o infrastruttura. 
Scrivendo Cloud Code, puoi estendere il tuo backend Back4app con logica aziendale aggiuntiva, validazioni, trigger e integrazioni che vengono eseguite in modo sicuro ed efficiente all'interno del Parse Server.
Come Funziona
Quando scrivi Cloud Code, di solito posizioni le tue funzioni JavaScript, trigger e eventuali moduli NPM richiesti in un main.js (o app.js) file. 
Questo file viene quindi distribuito al tuo progetto Back4app, che viene eseguito all'interno dell'ambiente Parse Server. 
Poiché queste funzioni e trigger vengono eseguiti sul server, puoi fidarti di loro per gestire logiche riservate, elaborare dati sensibili o effettuare chiamate API solo backend - processi che potresti non voler esporre direttamente al client.
Tutto il Cloud Code per la tua app Back4app viene eseguito all'interno del Parse Server gestito da Back4app, quindi non devi preoccuparti della manutenzione del server, della scalabilità o della fornitura. 
Ogni volta che aggiorni e distribuisci il tuo file main.js, il server Parse in esecuzione viene aggiornato con il tuo codice più recente.
Struttura del file main.js
Un tipico main.js potrebbe contenere:
Dichiarazioni Require per eventuali moduli necessari (pacchetti NPM, moduli Node integrati o altri file di codice cloud).
Definizioni di funzioni Cloud utilizzando Parse.Cloud.define().
Trigger come Parse.Cloud.beforeSave(), Parse.Cloud.afterSave(), ecc.
Moduli NPM che hai installato (se necessario).
main.js
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
Con la possibilità di installare e utilizzare moduli NPM, il codice Cloud diventa incredibilmente flessibile, permettendoti di integrarti con API esterne, eseguire trasformazioni dei dati o eseguire logica complessa lato server.
Casi d'uso tipici
Logica Aziendale: Ad esempio, aggregare dati per analisi o eseguire calcoli prima di salvare nel database.
Validazioni dei Dati: Assicurarsi che determinati campi siano presenti o che un utente abbia le autorizzazioni corrette prima di salvare o eliminare un record.
Trigger: Eseguire azioni quando i dati cambiano (ad es., inviare una notifica quando un utente aggiorna il proprio profilo).
Integrazioni: Connettersi con API o servizi di terze parti.
Applicazione della Sicurezza: Validare e sanificare gli input per applicare la sicurezza prima di eseguire operazioni sensibili.
Distribuisci la tua funzione
Di seguito è riportata una semplice funzione di Cloud Code che calcola la lunghezza di una stringa di testo inviata dal client:
main.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 };
});
﻿
Distribuzione tramite il Back4app CLI:
1 - Installa il CLI:
Per Linux/MacOS:
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
Per Windows:
Scarica il b4a.exe file dalla pagina delle versioni.
2 - Configura la tua chiave account:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
3 - Distribuisci il tuo codice cloud:
Bash
b4a deploy
b4a deploy
﻿
Distribuzione tramite il Dashboard:
Nel dashboard della tua app, vai su Cloud Code > Funzioni.
Copia/incolla la funzione nell' main.js editor.
Clicca su Distribuisci.
Chiamare la tua funzione
Da Blazor utilizzando il Parse .NET SDK:
SomeDataService.cs (calling function)
public async Task<int?> GetTextLengthAsync(string text) {
    try {
        var result = await ParseCloud.CallFunctionAsync<Dictionary<string, object>>("calculateTextLength", 
            new Dictionary<string, object> { { "text", text } });
        if(result != null && result.ContainsKey("length"))
            return Convert.ToInt32(result["length"]);
        return null;
    } catch(Exception ex) {
        Console.WriteLine("Error calling cloud function: " + ex.Message);
        return null;
    }
}
public async Task<int?> GetTextLengthAsync(string text) {
    try {
        var result = await ParseCloud.CallFunctionAsync<Dictionary<string, object>>("calculateTextLength", 
            new Dictionary<string, object> { { "text", text } });
        if(result != null && result.ContainsKey("length"))
            return Convert.ToInt32(result["length"]);
        return null;
    } catch(Exception ex) {
        Console.WriteLine("Error calling cloud function: " + ex.Message);
        return null;
    }
}
﻿
Puoi anche chiamarlo tramite REST o GraphQL come mostrato nel tutorial di ReactJS.
Passo 5 – Configurazione dell'autenticazione utente
Autenticazione Utente in Back4app
Back4app sfrutta la classe Parse User come base per l'autenticazione. Per impostazione predefinita, Parse gestisce l'hashing delle password, i token di sessione e lo storage sicuro. Questo significa che non devi impostare manualmente flussi di sicurezza complessi.
Impostazione dell'Autenticazione Utente
In un'applicazione Blazor, puoi creare un nuovo utente con:
AuthService.cs
using Parse;
using System.Threading.Tasks;

public class AuthService {
    public async Task SignUpUserAsync(string username, string password, string email) {
        var user = new ParseUser() {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User signed up successfully!");
        } catch (Exception ex) {
            Console.WriteLine("Error signing up user: " + ex.Message);
        }
    }

    public async Task LogInUserAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine("User logged in: " + user.Username);
        } catch (Exception ex) {
            Console.WriteLine("Error logging in user: " + ex.Message);
        }
    }
}
using Parse;
using System.Threading.Tasks;

public class AuthService {
    public async Task SignUpUserAsync(string username, string password, string email) {
        var user = new ParseUser() {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User signed up successfully!");
        } catch (Exception ex) {
            Console.WriteLine("Error signing up user: " + ex.Message);
        }
    }

    public async Task LogInUserAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine("User logged in: " + user.Username);
        } catch (Exception ex) {
            Console.WriteLine("Error logging in user: " + ex.Message);
        }
    }
}
﻿
Gestione delle Sessioni
Dopo un login riuscito, Parse crea un token di sessione che viene memorizzato nell'oggetto utente. Nella tua app Blazor, puoi accedere all'utente attualmente connesso:
SomeComponent.razor.cs
var currentUser = ParseUser.CurrentUser;
if (currentUser != null) {
    Console.WriteLine("Currently logged-in user: " + currentUser.Username);
} else {
    Console.WriteLine("No user is logged in");
}
var currentUser = ParseUser.CurrentUser;
if (currentUser != null) {
    Console.WriteLine("Currently logged-in user: " + currentUser.Username);
} else {
    Console.WriteLine("No user is logged in");
}
﻿
Parse gestisce automaticamente le sessioni basate su token in background, ma puoi anche gestirle o revocarle manualmente. Per disconnettersi:
AuthService.cs (logout)
public async Task LogOutAsync() {
    await ParseUser.LogOutAsync();
    Console.WriteLine("User logged out");
}
public async Task LogOutAsync() {
    await ParseUser.LogOutAsync();
    Console.WriteLine("User logged out");
}
﻿
Integrazione del Login Sociale
Back4app e Parse possono integrarsi con i popolari fornitori OAuth, come Google o Facebook. 
La configurazione può variare e spesso comporta impostazioni lato server o pacchetti aggiuntivi. Fare riferimento alla Documentazione sul Login Sociale per istruzioni dettagliate.
Poiché le app Blazor Server vengono eseguite su ASP.NET Core, potresti integrare il login sociale utilizzando i fornitori di identità ASP.NET Core insieme a Parse per un'autenticazione senza soluzione di continuità.
Verifica Email e Ripristino Password
Per abilitare la verifica email e il ripristino della password:
Naviga nelle Impostazioni Email nel tuo dashboard di Back4app.
Abilita la verifica email per garantire che i nuovi utenti verifichino la proprietà dei loro indirizzi email.
Configura l'indirizzo del mittente, i modelli email e il tuo dominio personalizzato se desiderato.
Queste funzionalità migliorano la sicurezza dell'account e l'esperienza dell'utente convalidando la proprietà degli email da parte degli utenti e fornendo un metodo sicuro di recupero della password.
Passo 6 – Gestione dello Storage dei File
Caricamento e Recupero dei File
Parse include la ParseFile classe per gestire i caricamenti di file, che Back4app memorizza in modo sicuro:
FileService.cs
using Parse;
using System;
using System.Threading.Tasks;

public class FileService {
    public async Task<string> UploadImageAsync(byte[] fileData, string fileName) {
        var parseFile = new ParseFile(fileName, fileData);
        try {
            await parseFile.SaveAsync();
            Console.WriteLine("File saved: " + parseFile.Url);
            return parseFile.Url;
        } catch (Exception ex) {
            Console.WriteLine("Error uploading file: " + ex.Message);
            return null;
        }
    }
}
using Parse;
using System;
using System.Threading.Tasks;

public class FileService {
    public async Task<string> UploadImageAsync(byte[] fileData, string fileName) {
        var parseFile = new ParseFile(fileName, fileData);
        try {
            await parseFile.SaveAsync();
            Console.WriteLine("File saved: " + parseFile.Url);
            return parseFile.Url;
        } catch (Exception ex) {
            Console.WriteLine("Error uploading file: " + ex.Message);
            return null;
        }
    }
}
﻿
Per allegare il file a un oggetto:
FileService.cs (continued)
public async Task<ParseObject> CreatePhotoObjectAsync(byte[] fileData, string fileName) {
    var photo = new ParseObject("Photo");
    var parseFile = new ParseFile(fileName, fileData);
    photo["imageFile"] = parseFile;

    try {
        await photo.SaveAsync();
        return photo;
    } catch (Exception ex) {
        Console.WriteLine("Error creating photo object: " + ex.Message);
        return null;
    }
}
public async Task<ParseObject> CreatePhotoObjectAsync(byte[] fileData, string fileName) {
    var photo = new ParseObject("Photo");
    var parseFile = new ParseFile(fileName, fileData);
    photo["imageFile"] = parseFile;

    try {
        await photo.SaveAsync();
        return photo;
    } catch (Exception ex) {
        Console.WriteLine("Error creating photo object: " + ex.Message);
        return null;
    }
}
﻿
Recupero dell'URL del file:
SomeComponent.razor.cs
var imageFile = photo.Get<ParseFile>("imageFile");
var imageUrl = imageFile.Url;
var imageFile = photo.Get<ParseFile>("imageFile");
var imageUrl = imageFile.Url;
﻿
Puoi visualizzare questo imageUrl nei tuoi componenti Blazor impostandolo come sorgente di un <img> tag.
Sicurezza dei File
Parse Server fornisce configurazioni flessibili per gestire la sicurezza del caricamento dei file. Usa ACL sui ParseFiles o imposta configurazioni a livello di server secondo necessità.
Passo 7 – Pianificazione dei Compiti con Cloud Jobs
Cloud Jobs
Cloud Jobs in Back4app ti permettono di pianificare ed eseguire compiti di routine sul tuo backend - come pulire dati obsoleti o inviare un'email di riepilogo giornaliero. Un tipico Cloud Job potrebbe apparire così:
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);

  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);
  }
});
﻿
Distribuisci il tuo Cloud Code con il nuovo lavoro (tramite CLI o la dashboard).
Vai alla Dashboard di Back4app > Impostazioni App > Impostazioni Server > Lavori in Background.
Pianifica il lavoro per essere eseguito quotidianamente o a qualsiasi intervallo soddisfi le tue esigenze.
﻿
I Cloud Jobs ti consentono di automatizzare la manutenzione in background o altri processi periodici senza richiedere intervento manuale.
Passo 8 – Integrazione dei Webhook
I Webhook consentono alla tua app Back4app di inviare richieste HTTP a un servizio esterno ogni volta che si verificano determinati eventi. 
Questo è potente per l'integrazione con sistemi di terze parti come gateway di pagamento, strumenti di email marketing o piattaforme di analisi.
Naviga nella configurazione dei Webhook nel tuo dashboard di Back4app > Altro > WebHooks e poi clicca su Aggiungi Webhook.
Imposta un endpoint (ad esempio, https://your-external-service.com/webhook-endpoint).
Configura i trigger per specificare quali eventi nelle tue classi Back4app o nelle funzioni Cloud Code attiveranno il webhook.
Ad esempio, se vuoi notificare un canale Slack ogni volta che viene creato un nuovo Todo:
Crea un'app Slack che accetta webhook in entrata.
Copia l'URL del webhook di Slack.
Nel tuo dashboard di Back4app, imposta l'endpoint su quell'URL di Slack per l'evento “Nuovo record nella classe Todo.”
Puoi anche aggiungere intestazioni HTTP personalizzate o payload se necessario.
Puoi anche definire i Webhook nel Cloud Code effettuando richieste HTTP personalizzate in trigger come beforeSave, afterSave.
Passo 9 – Esplorare il Pannello di Amministrazione di Back4app
Il Back4app Admin App è un'interfaccia di gestione basata sul web progettata per utenti non tecnici per eseguire operazioni CRUD e gestire attività di dati di routine senza scrivere codice.
Fornisce un interfaccia centrata sul modello, facile da usare che semplifica l'amministrazione del database, la gestione dei dati personalizzati e le operazioni a livello aziendale.
Abilitare l'App di Amministrazione
Abilitalo andando su App Dashboard > Altro > App di Amministrazione e cliccando sul pulsante “Abilita App di Amministrazione.”
Crea un Primo Utente Amministratore (nome utente/password), che genera automaticamente un nuovo ruolo (B4aAdminUser) e classi (B4aSetting, B4aMenuItem e B4aCustomField) nello schema della tua app.
Scegli un Sottodominio per accedere all'interfaccia di amministrazione e completare la configurazione.
Accedi utilizzando le credenziali di amministratore che hai creato per accedere al tuo nuovo dashboard dell'App di Amministrazione.
Una volta abilitata, l'App di Amministrazione di Back4app rende facile visualizzare, modificare o rimuovere record dal tuo database senza richiedere l'uso diretto del Parse Dashboard o del codice backend.
Conclusione
Seguendo questo tutorial completo, hai:
Creato un backend sicuro per un'app Blazor su Back4app.
Configurato un database con schemi di classe, tipi di dati e relazioni.
Integrato query in tempo reale dove applicabile per aggiornamenti immediati dei dati.
Applicato misure di sicurezza utilizzando ACL e CLP per proteggere e gestire l'accesso ai dati.
Implementato Cloud Code funzioni per eseguire logica aziendale personalizzata sul lato server.
Impostato l'autenticazione degli utenti con supporto per la verifica dell'email e il ripristino della password.
Gestito caricamenti di file e recupero, con controlli di sicurezza dei file opzionali.
Pianificato Cloud Jobs per attività di background automatizzate.
Utilizzato Webhook per integrarsi con servizi esterni.
Esplorato il Pannello di Amministrazione di Back4app per la gestione dei dati.
Con un solido frontend Blazor e un robusto backend Back4app, sei ora ben attrezzato per sviluppare applicazioni web ricche di funzionalità, scalabili e sicure.
Continua a esplorare funzionalità più avanzate, integra la tua logica aziendale e sfrutta la potenza di Back4app per risparmiare innumerevoli ore nella gestione di server e database. Buon coding!
Prossimi Passi
Crea un'app Blazor pronta per la produzione estendendo questo backend per gestire modelli di dati più complessi, strategie di caching e ottimizzazioni delle prestazioni.
Integra funzionalità avanzate come flussi di autenticazione specializzati, controllo degli accessi basato sui ruoli o API esterne.
Controlla la documentazione ufficiale di Back4app per approfondimenti su sicurezza avanzata, ottimizzazione delle prestazioni e analisi dei log.
Esplora altri tutorial su applicazioni di chat in tempo reale, dashboard IoT o servizi basati sulla posizione. Combina le tecniche apprese qui con API di terze parti per creare applicazioni complesse e reali.
﻿
Aggiornato 11 Feb 2025
Questa pagina ti è stata di aiuto?
Come costruire un'app CRUD con ReactJS?
AVANTI IL PROSSIMO
Come costruire un backend per htmx?