Quickstarters
Come costruire un backend per htmx?

34min
Introduzione
In questo tutorial, imparerai come costruire un backend completo per le app web htmx 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, l'archiviazione dei file e le query in tempo reale (Live Queries) - per creare un backend sicuro, scalabile e robusto che comunica senza problemi con il tuo front end htmx.
Utilizzare htmx, una moderna libreria JavaScript che sfrutta gli attributi html per gestire le interazioni lato client, può migliorare drasticamente l'esperienza utente mentre ci si concentra sul rendering lato server.
Combinando htmx con i potenti framework lato server e i motori di template di Back4app, gli sviluppatori possono creare app web full stack con facilità ed efficienza.
Alla fine di questo tutorial, avrai costruito un backend su misura per l'integrazione htmx, consentendo operazioni sui dati fluide e migliorando l'esperienza lato client con aggiornamenti dinamici delle pagine html senza ricaricare l'intera pagina.
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.
Impostazione di base di htmx
Includi la libreria htmx nella tua pagina html utilizzando:
Un ambiente di sviluppo web
Assicurati di avere un server locale configurato o utilizza framework lato server per servire i tuoi template html.
Familiarità con HTML, CSS e JavaScript
Documentazione htmx per ulteriori dettagli sugli attributi html e lo sviluppo di app web.
Assicurati di avere tutti questi prerequisiti in atto prima di iniziare. Avere il tuo progetto Back4app configurato e il tuo ambiente htmx locale pronto ti aiuterà a seguire più facilmente.
Passo 1 – Configurazione del Progetto Back4app
Crea un Nuovo Progetto
Il primo passo per costruire il tuo backend htmx 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, “htmx-Backend-Tutorial”).
﻿
Una volta creato il progetto, lo vedrai elencato nel tuo dashboard di Back4app. Questo progetto sarà la base per tutte le configurazioni del backend discusse in questo tutorial.
Collegati tramite REST API
Back4app si basa sulla Parse Platform per gestire i tuoi dati, fornire funzionalità in tempo reale, gestire l'autenticazione degli utenti e altro ancora. 
Sebbene htmx sia una libreria lato client, collegare il tuo front end htmx a Back4app implica effettuare chiamate REST API direttamente dal tuo html e JavaScript.
Recupera le tue chiavi Parse:
Nel tuo dashboard di Back4app, vai alla sezione “Impostazioni App” o “Sicurezza e Chiavi” della tua app per trovare il tuo ID Applicazione, Chiave REST API, e il URL del Server Parse (spesso nel formato https://parseapi.back4app.com).
Con queste chiavi, puoi utilizzare htmx per chiamare i tuoi endpoint backend e manipolare i tuoi modelli html di conseguenza. Ad esempio, potresti utilizzare richieste fetch di JavaScript combinate con attributi htmx per interagire con i tuoi dati tramite chiamate REST.
Passo 2 – Configurazione del Database
Salvataggio e Query dei Dati
Con il tuo progetto Back4app configurato, puoi ora iniziare a salvare e recuperare dati utilizzando chiamate REST API, che puoi attivare da richieste htmx o JavaScript semplice. Il modo più semplice per creare un record è effettuare una richiesta POST al server Parse:
Curl
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Allo stesso modo, puoi interrogare i dati:
Curl
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
﻿
Puoi anche utilizzare query GraphQL secondo necessità per interagire con il tuo database dal lato client.
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).
﻿
Back4app supporta vari tipi di dati come String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, e Polygon. Usa questi per progettare uno schema robusto per la tua applicazione basata su htmx.
Back4app offre un Agente AI che può aiutarti a progettare il tuo modello di dati:
Apri l'Agente AI dal tuo Dashboard App o dal menu.
Descrivi il tuo modello di dati in linguaggio semplice (ad esempio, “Per favore, crea una nuova App ToDo su back4app con uno schema di classe completo.”).
Lascia che l'Agente AI crei lo Schema per te.
﻿
Utilizzare l'Agente AI può farti risparmiare tempo nella configurazione della tua architettura dati e garantire coerenza nella tua applicazione.
Dati Relazionali
Se hai dati relazionali, come collegare compiti a categorie, puoi utilizzare Pointers o Relations in Parse tramite chiamate API REST. Ad esempio, aggiungendo un puntatore:
JS
// Example: Linking a Task to a Category using REST API
async function createTaskForCategory(categoryId, title) {
  const response = await fetch('https://parseapi.back4app.com/classes/Todo', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      title: title,
      category: {
        __type: "Pointer",
        className: "Category",
        objectId: categoryId
      }
    })
  });
  return response.json();
}
// Example: Linking a Task to a Category using REST API
async function createTaskForCategory(categoryId, title) {
  const response = await fetch('https://parseapi.back4app.com/classes/Todo', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      title: title,
      category: {
        __type: "Pointer",
        className: "Category",
        objectId: categoryId
      }
    })
  });
  return response.json();
}
﻿
Quando interroghi, includi i dati del puntatore secondo necessità:
JS
// Example: Querying with pointer inclusion
async function fetchTodos() {
  const response = await fetch('https://parseapi.back4app.com/classes/Todo?include=category', {
    headers: {
      'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY'
    }
  });
  return response.json();
}
// Example: Querying with pointer inclusion
async function fetchTodos() {
  const response = await fetch('https://parseapi.back4app.com/classes/Todo?include=category', {
    headers: {
      'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY'
    }
  });
  return response.json();
}
﻿
Interrogazioni in tempo reale
Per aggiornamenti in tempo reale, Back4app fornisce Interrogazioni in tempo reale. Mentre htmx si concentra sul rendering lato server e sugli attributi HTML, integrare aggiornamenti dal vivo può migliorare significativamente l'esperienza dell'utente.
Abilita le Interrogazioni in tempo reale nel tuo dashboard di Back4app sotto le Impostazioni del server. Assicurati che “Interrogazioni in tempo reale” sia attivato.
Inizializza un Abbonamento a Interrogazioni in tempo reale utilizzando JavaScript insieme ai trigger htmx se necessario:
(Nota: Le Interrogazioni in tempo reale richiedono tipicamente il Parse SDK; tuttavia, possono comunque funzionare insieme a htmx aggiornando parti della pagina quando i dati cambiano. Questo esempio dimostra il concetto.)
JS
import Parse from './parseConfig'; // This assumes use of the Parse SDK in JS environment

async function subscribeToTodos(callback) {
  const query = new Parse.Query('Todo');
  const subscription = await query.subscribe();

  subscription.on('create', (newTodo) => {
    console.log('New Todo created:', newTodo);
    callback('create', newTodo);
  });

  subscription.on('update', (updatedTodo) => {
    console.log('Todo updated:', updatedTodo);
    callback('update', updatedTodo);
  });

  subscription.on('delete', (deletedTodo) => {
    console.log('Todo deleted:', deletedTodo);
    callback('delete', deletedTodo);
  });

  return subscription;
}
import Parse from './parseConfig'; // This assumes use of the Parse SDK in JS environment

async function subscribeToTodos(callback) {
  const query = new Parse.Query('Todo');
  const subscription = await query.subscribe();

  subscription.on('create', (newTodo) => {
    console.log('New Todo created:', newTodo);
    callback('create', newTodo);
  });

  subscription.on('update', (updatedTodo) => {
    console.log('Todo updated:', updatedTodo);
    callback('update', updatedTodo);
  });

  subscription.on('delete', (deletedTodo) => {
    console.log('Todo deleted:', deletedTodo);
    callback('delete', deletedTodo);
  });

  return subscription;
}
﻿
Questa sottoscrizione può quindi attivare richieste htmx o aggiornare dinamicamente i modelli html per riflettere le modifiche sul lato client.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Meccanismo di Sicurezza di Back4app
Back4app prende sul serio la sicurezza fornendo Access Control Lists (ACLs) e Class-Level Permissions (CLPs). 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.
Access Control Lists (ACLs)
Un ACL è applicato a singoli oggetti per determinare quali utenti, ruoli o il pubblico possono eseguire operazioni di lettura/scrittura. Ad esempio:
JS
async function createPrivateTodo(title, ownerUser) {
  const response = await fetch('https://parseapi.back4app.com/classes/Todo', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      title: title,
      ACL: {
        [ownerUser.id]: { "read": true, "write": true },
        "*": { "read": false, "write": false }
      }
    })
  });
  return response.json();
}
async function createPrivateTodo(title, ownerUser) {
  const response = await fetch('https://parseapi.back4app.com/classes/Todo', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      title: title,
      ACL: {
        [ownerUser.id]: { "read": true, "write": true },
        "*": { "read": false, "write": false }
      }
    })
  });
  return response.json();
}
﻿
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 sezione Database.
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 oggetti individuali. 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 ti consente di eseguire codice JavaScript personalizzato sul lato server. 
Scrivendo il Cloud Code, puoi estendere il tuo backend Back4app con logica aziendale aggiuntiva, validazioni, trigger e integrazioni che vengono eseguite in modo sicuro ed efficiente sul Parse Server.
Come Funziona
Quando scrivi il Cloud Code, di solito posizioni le tue funzioni JavaScript, i trigger e eventuali moduli NPM richiesti in un main.js file. Questo file viene quindi distribuito al tuo progetto Back4app, che viene eseguito all'interno dell'ambiente del Parse Server.
JS
// main.js

const axios = require('axios');

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;
});

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

const axios = require('axios');

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;
});

Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
Distribuisci il tuo Cloud Code utilizzando il Back4app CLI o tramite il Dashboard.
Chiamare la Tua Funzione
Da un'interfaccia migliorata con htmx, puoi chiamare le tue funzioni Cloud Code utilizzando fetch JavaScript e aggiornare le parti della tua pagina html di conseguenza. Ad esempio:
JS
async function getTextLength(text) {
  const response = await fetch('https://parseapi.back4app.com/functions/calculateTextLength', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ text })
  });
  const result = await response.json();
  console.log('Text length:', result.result.length);
}
async function getTextLength(text) {
  const response = await fetch('https://parseapi.back4app.com/functions/calculateTextLength', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ text })
  });
  const result = await response.json();
  console.log('Text length:', result.result.length);
}
﻿
Puoi integrare chiamate simili all'interno dei tuoi trigger htmx e degli attributi html per creare comportamenti dinamici e reattivi sul lato client, migliorando l'esperienza complessiva dell'utente.
Passo 5 – Configurazione dell'Autenticazione Utente
Autenticazione Utente in Back4app
Back4app sfrutta la Parse User classe come base per l'autenticazione. Per impostazione predefinita, Parse gestisce l'hashing delle password, i token di sessione e lo storage sicuro. 
Nel contesto di un'applicazione htmx, l'autenticazione utente può essere gestita tramite chiamate REST avviate da invii di moduli html o richieste fetch JavaScript.
Impostare l'Autenticazione Utente
Ad esempio, per creare un nuovo utente:
JS
async function signUpUser(username, password, email) {
  const response = await fetch('https://parseapi.back4app.com/users', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ username, password, email })
  });
  return response.json();
}
async function signUpUser(username, password, email) {
  const response = await fetch('https://parseapi.back4app.com/users', {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ username, password, email })
  });
  return response.json();
}
﻿
Allo stesso modo, per il login dell'utente:
JS
async function logInUser(username, password) {
  const response = await fetch(`https://parseapi.back4app.com/login?username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}`, {
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY'
    }
  });
  return response.json();
}
async function logInUser(username, password) {
  const response = await fetch(`https://parseapi.back4app.com/login?username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}`, {
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY'
    }
  });
  return response.json();
}
﻿
Gestione delle sessioni
Dopo un login riuscito, Parse crea un token di sessione che puoi memorizzare e gestire nella tua applicazione htmx per richieste autenticate successive.
Integrazione del login sociale
Mentre htmx si concentra sugli attributi html e sulle interazioni lato server, l'integrazione dei login sociali come Google o Facebook può comunque essere realizzata avviando flussi OAuth e gestendo i callback sul lato server. Fare riferimento a Documentazione sul login sociale per indicazioni dettagliate.
Verifica dell'email e reimpostazione della password
Per abilitare la verifica dell'email e il ripristino della password:
Naviga nelle Impostazioni Email nel tuo dashboard di Back4app.
Abilita la verifica dell'email e configura i modelli necessari.
Usa fetch nei tuoi flussi htmx per attivare le richieste di ripristino della password secondo necessità.
Passo 6 – Gestione dello Storage dei File
Caricamento e Recupero dei File
Parse include capacità di storage dei file che puoi utilizzare tramite chiamate API REST dalla tua applicazione htmx. Ad esempio, per caricare un'immagine:
JS
async function uploadImage(file) {
  const data = new FormData();
  data.append('file', file);
  data.append('object', '{"__type":"File","name":"' + file.name + '"}');

  const response = await fetch('https://parseapi.back4app.com/files/' + file.name, {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY'
    },
    body: data
  });
  return response.json();
}
async function uploadImage(file) {
  const data = new FormData();
  data.append('file', file);
  data.append('object', '{"__type":"File","name":"' + file.name + '"}');

  const response = await fetch('https://parseapi.back4app.com/files/' + file.name, {
    method: 'POST',
    headers: {
      'X-Parse-Application-Id': 'YOUR_APP_ID',
      'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY'
    },
    body: data
  });
  return response.json();
}
﻿
Sicurezza dei File
Controlla chi può caricare e accedere ai file configurando le impostazioni di sicurezza in Back4app e impostando gli ACL sugli oggetti file secondo necessità.
Passo 7 – Pianificazione dei Compiti con Cloud Jobs
Cloud Jobs
I Cloud Jobs in Back4app ti permettono di pianificare compiti di routine sul tuo backend, come la pulizia dei dati obsoleti o l'invio di email periodiche.
Questi lavori vengono eseguiti lato server e possono essere integrati con il tuo flusso di lavoro htmx quando necessario.
JS
// 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);
  }
});
// 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);
  }
});
﻿
Pianifica questo lavoro tramite il Dashboard di Back4app sotto Impostazioni App > Impostazioni Server > Lavori in Background.
Passo 8 – Integrazione dei Webhook
Webhooks 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 Webhooks nel tuo dashboard di Back4app > Altro > WebHooks e 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, per 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.”
Facoltativamente, aggiungi intestazioni HTTP personalizzate o payload come necessario.
Puoi anche definire Webhooks nel Cloud Code effettuando richieste HTTP personalizzate nei trigger.
Passo 9 – Esplorare il Pannello di Amministrazione di Back4app
L' App di Amministrazione di Back4app è un'interfaccia di gestione basata sul web progettata per utenti non tecnici per eseguire operazioni CRUD e gestire attività di routine sui dati senza scrivere codice.
Fornisce un'interfaccia centrata sul modello e facile da usare che semplifica l'amministrazione del database, la gestione dei dati personalizzati e le operazioni a livello aziendale.
Abilitare l'App Admin
Abilita andando su App Dashboard > Altro > App Admin e cliccando sul pulsante “Abilita App Admin”.
Crea un Primo Utente Admin (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 admin e completare la configurazione.
Accedi utilizzando le credenziali admin che hai creato per accedere al tuo nuovo dashboard dell'App Admin.
Una volta abilitata, l'App Admin 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 su come costruire un backend per htmx utilizzando Back4app, hai:
Creato un backend sicuro su misura per le app web htmx.
Configurato un database con schemi di classe, tipi di dati e relazioni.
Integrato query in tempo reale e considerato come le Live Queries possano migliorare l'esperienza utente sul lato client.
Applicato misure di sicurezza utilizzando ACL e CLP per proteggere e gestire l'accesso ai dati.
Implementato funzioni di Cloud Code per eseguire logica aziendale personalizzata sul lato server.
Impostato l'autenticazione degli utenti, l'archiviazione dei file, i Cloud Jobs programmati e integrato i Webhook.
Esplorato il Pannello di Amministrazione di Back4app per una gestione efficiente dei dati.
Con questo robusto backend, puoi ora sfruttare le capacità di htmx per creare applicazioni web dinamiche e moderne che combinano miglioramenti sul lato client con potenti framework sul lato server.
Questo approccio full stack migliora l'esperienza utente complessiva, fornendo aggiornamenti delle pagine html fluidi, rendering efficiente sul lato server e integrazione senza soluzione di continuità attraverso il tuo stack tecnologico.
Prossimi Passi
Estendi questo backend per incorporare modelli di dati più complessi, motori di template avanzati e logica personalizzata sul lato server.
Esplora l'integrazione con framework sul lato server per creare un'esperienza più dinamica e reattiva sul lato client.
Controlla la documentazione ufficiale di Back4app per approfondimenti su sicurezza avanzata, ottimizzazione delle prestazioni e analisi.
Continua a imparare su htmx e lo sviluppo web moderno per costruire app web user-friendly e reattive che combinano il meglio delle tecnologie sul lato client e server.
﻿
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come-costruire-un-backend-per-il-Blazor
AVANTI IL PROSSIMO
Come costruire un backend per NativeScript?