Quickstarters
Come costruire un backend per Elixir?

40min
Introduzione
In questo tutorial, imparerai come costruire un backend per Elixir 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. 
Elixir, che gira sulla VM Erlang (BEAM) e sfrutta OTP (Erlang OTP), è noto per il suo ambiente tollerante ai guasti e concorrente, che si abbina bene a Back4App per formare un'infrastruttura moderna e ad alte prestazioni.
Vedrai come la rapida configurazione di Back4App e l'ambiente intuitivo possano ridurre drasticamente il tuo tempo e sforzo rispetto alla configurazione manuale di server e database. 
Questo include l'utilizzo del pattern matching, oltre a collegarsi al framework web di scelta di Elixir. 
Alla fine di questo tutorial, avrai una solida base che potrai estendere in un'applicazione pronta per la produzione o migliorare con logica personalizzata e API di terze parti.
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.
Ambiente di sviluppo Elixir di base
 Assicurati di avere Elixir installato sul tuo computer. Se prevedi di utilizzare un framework web come Phoenix, consulta la guida all'installazione di Phoenix per riferimento.
Familiarità con i concetti di Elixir
 Documentazione ufficiale di Elixir.
Se sei nuovo in Elixir, rivedi queste risorse o un tutorial per principianti prima di iniziare.
Assicurati di avere tutti questi prerequisiti in atto prima di iniziare. Avere il tuo progetto Back4App configurato e il tuo ambiente Elixir locale pronto ti aiuterà a seguire più agevolmente.
Passo 1 – Creare un nuovo progetto su Back4App e connettersi
Crea un nuovo progetto
Il primo passo in come costruire un backend per Elixir 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, “Elixir-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.
Collegamento tramite REST o GraphQL
Back4App utilizza la piattaforma Parse come base. Per Elixir, al momento non esiste un SDK ufficiale di Parse. Invece, puoi facilmente connetterti a Back4App utilizzando le API REST o GraphQL. Nel tuo progetto Elixir, dovrai:
Recupera il tuo Application ID e REST o GraphQL Keys dalla sezione “App Settings” o “Security & Keys” nel dashboard di Back4App.
Configura le richieste HTTP utilizzando una libreria Elixir come HTTPoison o Tesla.
Ad esempio, per memorizzare le credenziali in un file di configurazione (config/dev.exs o simile):
Text
config :my_app, :b4a,
  app_id: "YOUR_APPLICATION_ID",
  rest_key: "YOUR_REST_API_KEY",
  server_url: "https://parseapi.back4app.com"
config :my_app, :b4a,
  app_id: "YOUR_APPLICATION_ID",
  rest_key: "YOUR_REST_API_KEY",
  server_url: "https://parseapi.back4app.com"
﻿
Puoi quindi fare riferimento a queste credenziali nel tuo codice per effettuare chiamate REST. In tutta questa guida, mostreremo come interagire con il database di Back4App, il sistema utente e altre funzionalità utilizzando richieste standard HTTP o GraphQL.
Passo 2 – Configurazione del Database
Creare un modello di dati
In Back4App, i dati sono memorizzati in classi. Puoi creare una nuova classe nel dashboard di Back4App:
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
﻿
Creare un modello di dati utilizzando l'Agente AI
Back4App fornisce anche un Agente AI per aiutarti a descrivere e creare il tuo modello di dati:
Apri l'Agente AI dal tuo App Dashboard o dal menu.
Descrivi il tuo modello di dati in linguaggio semplice (ad esempio, “Per favore, crea una nuova App Todo con uno schema di classe completo.”).
Lascia che l'Agente AI crei lo schema automaticamente.
﻿
Lettura e scrittura dei dati utilizzando SDK (se applicabile)
Poiché Elixir non ha un SDK Parse ufficiale, salteremo l'uso diretto dell'SDK. Invece, mostreremo REST, GraphQL, e Live Queries approcci qui sotto.
Lettura e scrittura dei dati utilizzando REST API
Installa un client HTTP come HTTPoison nel tuo mix.exs:
Text
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
﻿
Poi, esegui mix deps.get.
Per creare (salvare) un oggetto Todo dalla tua applicazione Elixir:
Text
defmodule MyApp.Todo do
  @moduledoc false
  require Logger
  alias MyApp.Config

  def create_todo(title, is_completed) do
    url      = Config.server_url() <> "/classes/Todo"
    headers  = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body     = Jason.encode!(%{"title" => title, "isCompleted" => is_completed})

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("Todo created: #{resp_body}")
        {:ok, resp_body}

      {:ok, %HTTPoison.Response{status_code: status, body: error_body}} ->
        Logger.error("Error creating todo (#{status}): #{error_body}")
        {:error, error_body}

      {:error, error} ->
        Logger.error("HTTP error: #{inspect(error)}")
        {:error, error}
    end
  end
end
defmodule MyApp.Todo do
  @moduledoc false
  require Logger
  alias MyApp.Config

  def create_todo(title, is_completed) do
    url      = Config.server_url() <> "/classes/Todo"
    headers  = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body     = Jason.encode!(%{"title" => title, "isCompleted" => is_completed})

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("Todo created: #{resp_body}")
        {:ok, resp_body}

      {:ok, %HTTPoison.Response{status_code: status, body: error_body}} ->
        Logger.error("Error creating todo (#{status}): #{error_body}")
        {:error, error_body}

      {:error, error} ->
        Logger.error("HTTP error: #{inspect(error)}")
        {:error, error}
    end
  end
end
﻿
E per interrogare i tuoi oggetti Todo:
Text
def fetch_todos() do
  url     = Config.server_url() <> "/classes/Todo"
  headers = [
    {"X-Parse-Application-Id", Config.app_id()},
    {"X-Parse-REST-API-Key", Config.rest_key()}
  ]

  HTTPoison.get(url, headers)
end
def fetch_todos() do
  url     = Config.server_url() <> "/classes/Todo"
  headers = [
    {"X-Parse-Application-Id", Config.app_id()},
    {"X-Parse-REST-API-Key", Config.rest_key()}
  ]

  HTTPoison.get(url, headers)
end
﻿
Lettura e Scrittura dei Dati utilizzando l'API GraphQL
Puoi anche interagire tramite GraphQL. Ad esempio, creando un Todo:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
In Elixir, potresti inviare questo anche con un client HTTP:
Text
graph_query = """
mutation {
  createTodo(input: {
    fields: {
      title: "New from GraphQL",
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
    }
  }
}
"""

url = Config.server_url() <> "/graphql"
headers = [
  {"X-Parse-Application-Id", Config.app_id()},
  {"X-Parse-REST-API-Key", Config.rest_key()},
  {"Content-Type", "application/json"}
]

HTTPoison.post(url, Jason.encode!(%{"query" => graph_query}), headers)
graph_query = """
mutation {
  createTodo(input: {
    fields: {
      title: "New from GraphQL",
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
    }
  }
}
"""

url = Config.server_url() <> "/graphql"
headers = [
  {"X-Parse-Application-Id", Config.app_id()},
  {"X-Parse-REST-API-Key", Config.rest_key()},
  {"Content-Type", "application/json"}
]

HTTPoison.post(url, Jason.encode!(%{"query" => graph_query}), headers)
﻿
Lavorare con le Query Live (Opzionale)
Per aggiornamenti in tempo reale, Back4App offre Live Queries. Puoi abilitare le Live Queries nelle Impostazioni del Server. Poiché attualmente non esiste una libreria client Parse nativa per Elixir, di solito ti connetteresti tramite un canale Phoenix o qualsiasi client WebSocket personalizzato all'endpoint fornito wss://YOUR_SUBDOMAIN_HERE.b4a.io. Questo può essere più avanzato, richiedendo codifica personalizzata per gestire abbonamenti, messaggi, ecc.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Panoramica Breve
Back4App offre Liste di Controllo degli Accessi (ACL) e Permessi a Livello di Classe (CLP) per proteggere e gestire l'accesso ai dati. Le ACL si applicano a singoli oggetti, mentre i CLP si applicano all'intera classe.
﻿
Passo dopo passo
Permessi a Livello di Classe (CLP): Nel tuo Dashboard di Back4App, sotto Database, seleziona una classe (ad esempio, “Todo”) e apri la scheda Permessi a Livello di Classe. Regola le impostazioni (ad esempio, “Richiede Autenticazione” o “Nessun Accesso” per il pubblico).
Configura ACL: Quando crei o aggiorni un oggetto, puoi inviare i dati ACL nella tua richiesta REST o GraphQL. Ad esempio, specifica il _ACL campo in JSON se hai bisogno di un controllo dettagliato per oggetto.
Modifica ACL
﻿
Per ulteriori informazioni, visita le Linee Guida sulla Sicurezza dell'App.
Passo 4 – Scrivere Funzioni di Cloud Code
Perché Cloud Code
Il Cloud Code ti consente di eseguire logica lato server senza gestire i tuoi server. Con Elixir, di solito ti affidi a OTP per la concorrenza, ma qui puoi semplicemente creare Cloud Code in JavaScript in Back4App per gestire la convalida, i trigger o la logica aziendale personalizzata. Questo codice viene eseguito su Parse Server, quindi puoi mantenere il tuo codice Elixir focalizzato su attività client o microservizi mentre il lavoro pesante avviene nel Cloud Code.
Funzione Esempio
Nel tuo main.js nel Dashboard di Back4App o utilizzando la CLI:
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
Distribuisci tramite il Back4app CLI o incollando nel dashboard sotto Cloud Code > Funzioni e cliccando Distribuisci.
﻿
Chiamare il Cloud Code
Da Elixir, potresti usare:
Text
defmodule MyApp.CloudFunctions do
  alias MyApp.Config

  def calculate_text_length(text) do
    url = Config.server_url() <> "/functions/calculateTextLength"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{text: text})

    HTTPoison.post(url, body, headers)
  end
end
defmodule MyApp.CloudFunctions do
  alias MyApp.Config

  def calculate_text_length(text) do
    url = Config.server_url() <> "/functions/calculateTextLength"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{text: text})

    HTTPoison.post(url, body, headers)
  end
end
﻿
Passo 5 – Configurazione dell'autenticazione
Abilita o Configura l'Autenticazione
Back4App utilizza la classe User per l'autenticazione. Puoi gestire facilmente la registrazione, il login e il ripristino della password. Da Elixir, di solito utilizzerai chiamate REST:
Text
defmodule MyApp.Auth do
  alias MyApp.Config

  def sign_up_user(username, password, email) do
    url = Config.server_url() <> "/users"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{
      username: username,
      password: password,
      email: email
    })

    HTTPoison.post(url, body, headers)
  end

  def log_in_user(username, password) do
    url = Config.server_url() <> "/login?username=#{username}&password=#{password}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()}
    ]

    HTTPoison.get(url, headers)
  end
end
defmodule MyApp.Auth do
  alias MyApp.Config

  def sign_up_user(username, password, email) do
    url = Config.server_url() <> "/users"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{
      username: username,
      password: password,
      email: email
    })

    HTTPoison.post(url, body, headers)
  end

  def log_in_user(username, password) do
    url = Config.server_url() <> "/login?username=#{username}&password=#{password}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()}
    ]

    HTTPoison.get(url, headers)
  end
end
﻿
Accesso Sociale
Back4App supporta l'integrazione con Google, Apple, Facebook e altro ancora. Nella maggior parte dei casi, indirizzerai gli utenti al flusso OAuth, quindi utilizzerai i token restituiti da questi fornitori per completare il login di Parse. Vedi Documentazione Accesso Sociale per dettagli.
Passo 6 – Gestione dello Storage dei File
Impostazione dello Storage dei File
Back4App memorizza i file in modo sicuro. Da Elixir, puoi caricare file tramite REST:
Text
defmodule MyApp.FileStorage do
  alias MyApp.Config
  require Logger

  def upload_file(file_path) do
    file_name = Path.basename(file_path)
    url = Config.server_url() <> "/files/#{file_name}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/octet-stream"}
    ]
    body = File.read!(file_path)

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("File uploaded: #{resp_body}")
        {:ok, resp_body}
      error ->
        Logger.error("Error uploading file: #{inspect(error)}")
        error
    end
  end
end
defmodule MyApp.FileStorage do
  alias MyApp.Config
  require Logger

  def upload_file(file_path) do
    file_name = Path.basename(file_path)
    url = Config.server_url() <> "/files/#{file_name}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/octet-stream"}
    ]
    body = File.read!(file_path)

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("File uploaded: #{resp_body}")
        {:ok, resp_body}
      error ->
        Logger.error("Error uploading file: #{inspect(error)}")
        error
    end
  end
end
﻿
Riceverai una risposta JSON con l'URL del file, che puoi memorizzare in una classe (ad esempio, Foto) per riferimento.
Considerazioni sulla Sicurezza
Puoi configurare chi può caricare file nelle impostazioni fileUpload del tuo progetto Back4App, limitando i caricamenti agli utenti autenticati se desiderato.
Passo 7 – Verifica Email e Reimpostazione Password
Panoramica
La verifica dell'email assicura che gli utenti possiedano l'indirizzo email utilizzato durante la registrazione. Il ripristino della password consente loro di recuperare gli account in modo sicuro. Entrambe le funzionalità sono integrate in Back4App.
Configurazione del Dashboard di Back4App
Abilita la verifica dell'email nelle “Impostazioni App” o “Autenticazione” della tua app.
Configura il Indirizzo del mittente e i modelli di email.
Abilita il ripristino della password per consentire agli utenti di reimpostare tramite un link inviato via email.
Codice/Implementazione
Una volta abilitato nel dashboard, puoi attivare i ripristini della password:
Text
defmodule MyApp.Auth do
  def request_password_reset(email) do
    url = Config.server_url() <> "/requestPasswordReset"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{email: email})

    HTTPoison.post(url, body, headers)
  end
end
defmodule MyApp.Auth do
  def request_password_reset(email) do
    url = Config.server_url() <> "/requestPasswordReset"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{email: email})

    HTTPoison.post(url, body, headers)
  end
end
﻿
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Quali lavori nel cloud fare
I lavori nel cloud ti permettono di automatizzare compiti di routine come la pulizia dei dati obsoleti o l'invio di email periodiche. Li scrivi in Cloud Code.
Esempio
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);
  }
});
﻿
Distribuisci il codice.
Vai al Dashboard di Back4app > Impostazioni App > Impostazioni Server > Lavori in Background.
Pianifica il lavoro per essere eseguito quotidianamente o con una frequenza a tua scelta.
Pianificazione di un lavoro nel cloud
﻿
Passo 9 – Integrazione dei Webhook
Definizione
I Webhook consentono alla tua applicazione Back4App di inviare richieste HTTP a un servizio esterno (ad esempio, un canale Slack o Stripe) quando si verificano determinati eventi.
Configurazione
Naviga alla configurazione dei Webhook nel tuo dashboard di Back4App > Altro > Webhook.
Imposta l'endpoint (ad esempio, https://your-service.com/webhook-endpoint).
Configura i trigger come “Nuovo record nella classe Todo.”
Aggiunta di un Webhook
﻿
Esempio
Se desideri inviare dati a Slack ogni volta che viene creato un Todo, puoi aggiungere un nuovo webhook che punta al tuo URL del webhook in entrata di Slack. Puoi anche definire i Webhook nel Cloud Code inviando richieste HTTP personalizzate in trigger come afterSave.
Webhook BeforeSave
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
Dove Trovarlo
L' App di Amministrazione di Back4app è un'interfaccia user-friendly per gestire i tuoi dati. Puoi attivarla da App Dashboard > Altro > App di Amministrazione.
Abilita l'App di Amministrazione
﻿
Caratteristiche
Crea un Primo Utente Amministratore, che imposta il ruolo di B4aAdminUser e classi aggiuntive.
Assegna un Sottodominio per accedere all'interfaccia di amministrazione.
Accedi per visualizzare e gestire i dati in un'interfaccia semplice.
﻿
Conclusione
Seguendo questo tutorial su come costruire un backend per Elixir con Back4App, hai:
Creato un backend sicuro sulla piattaforma di Back4App utilizzando Elixir per l'integrazione.
Impostato un database con classi, tipi di dati e relazioni.
Utilizzato REST/GraphQL per interagire con i tuoi dati da Elixir.
Applicato la sicurezza utilizzando ACL e CLP.
Aggiunto logica personalizzata con funzioni di Cloud Code.
Configurato l'autenticazione degli utenti con verifica email e reset della password.
Gestito lo storage dei file e il recupero.
Pianificato lavori in background per l'automazione.
Integrato servizi esterni con webhook.
Esplorato il Pannello di Amministrazione di Back4App per una facile gestione dei dati.
Con il modello di concorrenza di Elixir (alimentato dal VM Erlang) e OTP, combinato con i servizi scalabili e flessibili di Back4App, puoi costruire backend altamente robusti.
Continua a esplorare funzionalità più avanzate, integra la tua logica aziendale e lascia che Back4App ti aiuti a gestire il lavoro pesante.
Prossimi Passi
Costruisci un'app Elixir pronta per la produzione sovrapponendo questo backend con il tuo framework web Elixir/Phoenix preferito.
Integra funzionalità avanzate come il controllo degli accessi basato sui ruoli o API di terze parti (gateway di pagamento, servizi di messaggistica).
Esplora la documentazione ufficiale di Back4app per sicurezza avanzata, registri, ottimizzazione delle prestazioni e altro.
Dai un'occhiata ad altri tutorial per app in tempo reale, dashboard IoT o servizi basati sulla posizione. Con il pattern matching e la concorrenza OTP a tua disposizione, sei pronto ad affrontare una vasta gamma di applicazioni!
﻿
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Ruby?
AVANTI IL PROSSIMO
Come costruire un backend per Play Framework?