Quickstarters
Come creare un backend per Ruby On Rails?

34min
Introduzione
In questo tutorial, imparerai come costruire un backend per Ruby on Rails utilizzando Back4App.
Esploreremo i passaggi chiave per integrare la tua applicazione Rails con le funzionalità essenziali di Back4App—come interazioni con il database, Funzioni Cloud Code, API REST e GraphQL, autenticazione degli utenti e query in tempo reale (Live Queries)—tutto in esecuzione sul lato server.
Sfruttando il linguaggio di programmazione Ruby, costruirai un'architettura robusta e scalabile che si allinea con il pattern MVC (Model-View-Controller) in Rails, consentendo agli sviluppatori di accelerare lo sviluppo delle applicazioni web.
Scoprirai anche come Back4App riduce drasticamente tempo e sforzo semplificando la gestione del server e del database.
Queste funzionalità automatizzate possono salvarti dalla necessità di configurare manualmente un server web o di affrontare infrastrutture complesse.
Alla fine, avrai una struttura flessibile e sicura, pronta per la produzione o ulteriori espansioni—come integrazioni aggiuntive e logica personalizzata avanzata.
Che tu voglia servire pagine web o alimentare applicazioni web basate sui dati, Rails e Back4App offrono una sinergia senza soluzione di continuità per creare soluzioni moderne in linguaggi di programmazione popolari.
Requisiti
Per completare questo tutorial, avrai bisogno di:
Un account Back4App e un nuovo progetto Back4App
 Iniziare con Back4app.
Se non hai un account, puoi crearne uno gratuitamente. Segui la guida sopra per preparare il tuo progetto.
Un ambiente di sviluppo Ruby on Rails
Assicurati di avere Ruby installato (preferibilmente versione 2.7 o superiore) e il gem Rails (Rails 6 o superiore). Installa Rails﻿
Parse Ruby Client
Se intendi utilizzare direttamente il Parse SDK, puoi installare il parse-ruby-client gem per gestire le operazioni sui dati con Back4App.
Familiarità con Rails MVC
Se sei nuovo a Ruby on Rails, rivedi le guide ufficiali di Rails o un tutorial per principianti per comprendere l' architettura del controller di visualizzazione MVC di Rails prima di iniziare.
Assicurati che questi requisiti siano in atto prima di iniziare. Avere il tuo progetto Back4App configurato, oltre al tuo applicazione Rails pronto, garantisce un'esperienza di tutorial fluida.
Passo 1 – Creare un Nuovo Progetto su Back4App e connettersi
Crea un Nuovo Progetto
Il primo passo per impostare un backend lato server per la tua applicazione Rails è creare un nuovo progetto su Back4App. Se non lo hai già fatto:
Accedi al tuo account Back4app.
Clicca sul pulsante “Nuova App” nel tuo dashboard di Back4App.
Dai un nome alla tua app (ad esempio, “Rails-Backend-Tutorial”).
﻿
Una volta creato il progetto, sarà visibile nel tuo dashboard di Back4App. Questo nuovo progetto forma il nucleo di tutte le configurazioni backend in questo tutorial.
Collegare il Parse SDK (Opzionale: parse-ruby-client)
Per semplificare le interazioni con il database e le query in tempo reale, Back4App utilizza la piattaforma Parse. Se desideri integrare il tuo server Rails direttamente con Parse, puoi installare la gemma parse-ruby-client. In caso contrario, puoi fare affidamento su endpoint REST o GraphQL standard.
Recupera le tue Chiavi Parse:
Nel tuo dashboard di Back4App, vai alle “Impostazioni App” o “Sicurezza e Chiavi” della tua app per trovare il tuo ID Applicazione e Chiave API REST. Otterrai anche il tuo URL del Server Parse (ad esempio, https://parseapi.back4app.com).
﻿
Aggiungi la gemma parse-ruby-client al tuo Gemfile:
Ruby
gem 'parse-ruby-client'
gem 'parse-ruby-client'
﻿
Poi esegui:
Bash
bundle install
bundle install
﻿
Inizializza Parse in un inizializzatore, come config/initializers/parse.rb:
Ruby
# config/initializers/parse.rb
require 'parse'

Parse.init application_id:  'YOUR_APPLICATION_ID',
           api_key:         'YOUR_REST_API_KEY',
           server_url:      'https://parseapi.back4app.com'
# config/initializers/parse.rb
require 'parse'

Parse.init application_id:  'YOUR_APPLICATION_ID',
           api_key:         'YOUR_REST_API_KEY',
           server_url:      'https://parseapi.back4app.com'
﻿
A questo punto, la tua applicazione Rails è in grado di comunicare con Back4App per memorizzare e recuperare dati, orchestrare logica personalizzata e altro. Questo approccio integrato semplifica il modo in cui la tua app Ruby on Rails gestisce il backend.
Passo 2 – Configurazione del Database
Creazione di un Modello di Dati
In molte applicazioni web, definisci la tua struttura dati in Rails utilizzando le migrazioni di ActiveRecord. Con Back4App, hai anche l'opzione di costruire il tuo schema direttamente sulla dashboard. Ad esempio, se hai un Todo modello:
Naviga su “Database” nella tua dashboard di Back4App.
Crea una nuova classe chiamata “Todo” e aggiungi colonne come title (String) e isCompleted (Boolean).
Crea Nuova Classe
﻿
Back4App supporta String, Number, Boolean, Date, File, Pointer, Relation, Array, GeoPoint, e Polygon. Rails gestisce tipicamente questi all'interno delle sue definizioni di modello, ma puoi anche lasciare che Parse crei colonne automaticamente al primo salvataggio (se utilizzi il Parse SDK o le API REST/GraphQL).
Crea Colonna
﻿
Creazione di un Modello Dati Utilizzando l'Agente AI
L'agente AI di Back4App può automatizzare la creazione dello schema:
Apri l'Agente AI dalla tua dashboard.
Descrivi il tuo modello dati (ad esempio, “Per favore crea una nuova App ToDo con uno schema di classe completo.”).
Lascia che l'agente generi il tuo schema.
﻿
Lettura e Scrittura Dati utilizzando SDK
Se scegli di integrare il parse-ruby-client, puoi memorizzare un record in questo modo:
Ruby
# app/controllers/todos_controller.rb

def create
  todo_class = Parse::Object.new('Todo')
  todo_class['title']       = params[:title]
  todo_class['isCompleted'] = false

  begin
    todo_class.save
    render json: { message: 'Todo saved successfully' }
  rescue => e
    render json: { error: e.message }, status: 500
  end
end

def index
  query = Parse::Query.new('Todo')
  results = query.get
  render json: results
end
# app/controllers/todos_controller.rb

def create
  todo_class = Parse::Object.new('Todo')
  todo_class['title']       = params[:title]
  todo_class['isCompleted'] = false

  begin
    todo_class.save
    render json: { message: 'Todo saved successfully' }
  rescue => e
    render json: { error: e.message }, status: 500
  end
end

def index
  query = Parse::Query.new('Todo')
  results = query.get
  render json: results
end
﻿
Lettura e scrittura dei dati utilizzando l'API REST
In alternativa, puoi utilizzare chiamate REST all'interno del tuo codice Rails (o di qualsiasi client esterno). Ad esempio, per creare un Todo:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Finish Rails Guide", "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": "Finish Rails Guide", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Lettura e scrittura dei dati utilizzando l'API GraphQL
Back4App offre anche GraphQL:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Plan web pages"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Plan web pages"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Lavorare con le query live (opzionale)
Se desideri aggiornamenti in tempo reale nella tua applicazione Rails, puoi iscriverti alle query live da un client front-end o WebSocket. Abilita le query live nelle Impostazioni del server, quindi connettiti a wss://YOUR_SUBDOMAIN.b4a.io per un flusso continuo di modifiche. Questo è utile per applicazioni web dinamiche che necessitano di aggiornamenti immediati dei dati.
Passo 3 – Applicare la sicurezza con ACL e CLP
Panoramica breve
La sicurezza è fondamentale nello sviluppo di applicazioni web. Back4App offre Liste di controllo degli accessi (ACL) e Permessi a livello di classe (CLP) per controllare la visibilità dei dati sia a livello di oggetto che di classe. Questo aiuta a garantire che solo gli utenti autenticati o autorizzati possano leggere/scrivere dati sensibili.
﻿
Impostare i permessi a livello di classe
Vai al Database nel tuo dashboard di Back4App.
Seleziona una Classe (ad esempio, “Todo”).
Apri la scheda CLP per configurare l'accesso in lettura/scrittura per ruoli, utenti autenticati o il pubblico.
Configurazione delle ACL
Puoi impostare un'ACL su un oggetto in modo che solo un utente specifico possa leggerlo o modificarlo. In Rails con parse-ruby-client, potrebbe apparire così:
Ruby
todo = Parse::Object.new('Todo')
acl  = Parse::ACL.new

# Set read/write for a user
acl.set_read_access_for(user_id, true)
acl.set_write_access_for(user_id, true)

todo.ACL = acl
todo.save
todo = Parse::Object.new('Todo')
acl  = Parse::ACL.new

# Set read/write for a user
acl.set_read_access_for(user_id, true)
acl.set_write_access_for(user_id, true)

todo.ACL = acl
todo.save
﻿
Passo 4 – Scrivere Funzioni di Cloud Code
Perché Cloud Code
Il Cloud Code esegue JavaScript lato server, consentendo agli sviluppatori di aggiungere logica personalizzata, trigger e validazioni senza gestire il proprio server web. Potresti voler gestire logica server aggiuntiva o effettuare controlli prima di salvare i dati.
Funzione di Esempio
Di seguito è riportato un esempio in JavaScript. Mentre il tuo server Rails gestisce l'app principale, puoi comunque utilizzare il Cloud Code per elaborare i dati:
JS
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Distribuzione
Distribuisci tramite il Back4App CLI o dal Back4App Dashboard. Il Cloud Code è un modo conveniente per incapsulare la logica condivisa tra tutti i client, indipendentemente da quali linguaggi di programmazione utilizzano. Con il supporto per i moduli basati su node (NPM), puoi integrare pacchetti esterni senza problemi.
Passo 5 – Configurazione dell'Autenticazione
Abilita l'Autenticazione Utente
Back4App gestisce le registrazioni degli utenti, i login e le sessioni con la classe User integrata di Parse. Puoi creare un utente con una chiamata REST o tramite qualsiasi SDK ufficiale.
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "john", "password": "secretpass"}' \
  https://parseapi.back4app.com/users
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "john", "password": "secretpass"}' \
  https://parseapi.back4app.com/users
﻿
Accesso Sociale
Puoi integrare i flussi di accesso di Facebook, Google o Apple. Ogni fornitore ha un approccio leggermente diverso, ma il principio principale è scambiare token con Parse. Controlla la Documentazione Accesso Sociale per dettagli su come integrarli nella tua applicazione rails.
Passo 6 – Gestione dello Storage dei File
Impostazione dello Storage dei File
Utilizzare Parse per i file è semplice come caricarli tramite l'API di Parse. Se stai utilizzando il parse-ruby-client:
Ruby
file_data = File.open('path/to/image.jpg')
parse_file = Parse::File.new('image.jpg', file_data)

begin
  parse_file.save
  puts "File uploaded: #{parse_file.url}"
rescue => e
  puts "Error uploading file: #{e.message}"
end
file_data = File.open('path/to/image.jpg')
parse_file = Parse::File.new('image.jpg', file_data)

begin
  parse_file.save
  puts "File uploaded: #{parse_file.url}"
rescue => e
  puts "Error uploading file: #{e.message}"
end
﻿
Esempio
Puoi quindi allegare questo file a un oggetto:
Ruby
photo_obj = Parse::Object.new('Photo')
photo_obj['imageFile'] = parse_file
photo_obj.save
photo_obj = Parse::Object.new('Photo')
photo_obj['imageFile'] = parse_file
photo_obj.save
﻿
﻿
Passo 7 – Verifica Email e Reimpostazione Password
Abilita la verifica email nel tuo Dashboard di Back4App sotto Impostazioni Email.
Imposta la reimpostazione della password personalizzando il modello di email e le impostazioni del dominio.
Attiva i flussi email automaticamente dopo la registrazione dell'utente o quando un utente richiede una reimpostazione della password. Questo garantisce una maggiore sicurezza e aiuta a confermare la validità della proprietà dell'email.
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Lavori Cloud
Se vuoi automatizzare compiti come la pulizia dei dati o l'invio di riepiloghi giornalieri, usa i Lavori Cloud:
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);
  }
});
﻿
Puoi pianificare tali lavori nel Dashboard di Back4App sotto Impostazioni del Server > Lavori in Background per eseguirli quotidianamente o a intervalli desiderati.
Passo 9 – Integrazione dei Webhook
I webhook consentono alla tua app Back4App di inviare dati a un URL esterno ogni volta che si verificano determinati eventi. Puoi inoltrare dati di oggetti nuovi o aggiornati a un altro sistema—come Stripe o Slack.
Vai su Altro > WebHooks nel tuo dashboard di Back4App.
Aggiungi un nuovo webhook che punta al tuo URL esterno (ad esempio, una rotta nel tuo controller Rails).
Specifica l'evento che attiva il webhook.
Aggiungere un Webhook
﻿
Se preferisci, puoi anche attivare un webhook dal Cloud Code effettuando una richiesta HTTP in una funzione beforeSave o afterSave.
BeforeSave WebHook
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
L' App di Amministrazione di Back4App offre un modo intuitivo per i team o i clienti non tecnici di eseguire operazioni CRUD sui tuoi dati di Back4App. Questa interfaccia elimina la necessità di modifiche dirette al codice o dell'uso del Parse Dashboard per compiti di base.
Dove trovarlo
Puoi abilitare l'App di Amministrazione dal tuo dashboard andando su Altro > App di Amministrazione e cliccando su Abilita App di Amministrazione.
Abilita l'app Admin
﻿
Caratteristiche
Una volta abilitato, puoi:
Creare e gestire dati senza scrivere query.
Monitorare i log, pianificare lavori in background e gestire le notifiche push (se abilitate).
Fornire accesso basato sui ruoli ai membri del team per una modifica più sicura.
﻿
Conclusione
Congratulazioni! Hai imparato come costruire un backend per Ruby on Rails utilizzando Back4App. In questo tutorial, hai:
Configurato un progetto Rails per interagire con Back4App tramite REST, GraphQL o il Parse Ruby Client.
Impostato interazioni sicure con il database utilizzando schemi di classe, ACL, CLP e query live opzionali.
Integrata l'autenticazione degli utenti con verifica email e reset della password.
Distribuito Cloud Code per logica personalizzata, trigger e attività pianificate.
Gestito caricamenti di file, sfruttato webhook ed esplorato il Pannello di Amministrazione.
Combinando l'architettura MVC di Ruby on Rails con il robusto set di funzionalità di Back4App, la tua applicazione Rails può scalare senza problemi.
Risparmierai tempo considerevole nella gestione dell'infrastruttura, permettendoti di concentrarti sulla creazione di applicazioni web con esperienze utente raffinate e logica server-side affidabile.
Prossimi Passi
Estendi la tua app Rails aggiungendo relazioni più complesse, strategie di caching o integrazioni avanzate.
Incorpora API di terze parti (come i gateway di pagamento) e sfrutta il Cloud Code per uno sviluppo più profondo delle applicazioni web.
Esplora la documentazione ufficiale di Back4App per sicurezza avanzata, ottimizzazione delle prestazioni, analisi dei log e altro.
Sperimenta con funzionalità in tempo reale per creare app di chat o piattaforme collaborative—ideali per dati che cambiano frequentemente.
Con questi fondamenti in atto, puoi sviluppare, iterare e scalare rapidamente il tuo server Rails per applicazioni web moderne. Buon coding!
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Yii 2?
AVANTI IL PROSSIMO
Come costruire un backend per Ruby?