Quickstarters
Comment construire un backend pour Elixir ?

41min
Introduction
Dans ce tutoriel, vous apprendrez comment construire un backend pour Elixir en utilisant Back4App. 
Nous allons passer en revue l'intégration des fonctionnalités essentielles de Back4App—telles que la gestion de base de données, les fonctions Cloud Code, les API REST et GraphQL, l'authentification des utilisateurs et les requêtes en temps réel (Live Queries)—pour créer un backend sécurisé, évolutif et robuste. 
Elixir, fonctionnant sur la VM Erlang (BEAM) et tirant parti d'OTP (Erlang OTP), est connu pour son environnement tolérant aux pannes et concurrent, qui s'associe bien avec Back4App pour former une infrastructure moderne et haute performance.
Vous verrez comment la configuration rapide de Back4App et son environnement intuitif peuvent réduire considérablement votre temps et vos efforts par rapport à la configuration manuelle des serveurs et des bases de données. 
Cela inclut l'utilisation de la correspondance de motifs, ainsi que l'intégration dans le framework web de choix d'Elixir. 
À la fin de ce tutoriel, vous aurez une base solide que vous pourrez étendre en une application prête pour la production ou améliorer avec une logique personnalisée et des API tierces.
Prérequis
Pour compléter ce tutoriel, vous aurez besoin de :
Un compte Back4App et un nouveau projet Back4App
 Guide de démarrage avec Back4app.
Si vous n'avez pas de compte, vous pouvez en créer un gratuitement. Suivez le guide ci-dessus pour préparer votre projet.
Environnement de développement Elixir de base
 Assurez-vous d'avoir Elixir installé sur votre machine. Si vous prévoyez d'utiliser un framework web tel que Phoenix, consultez le guide d'installation de Phoenix pour référence.
Familiarité avec les concepts Elixir
 Documentation officielle d'Elixir.
Si vous êtes nouveau dans Elixir, consultez ces ressources ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4App configuré et votre environnement Elixir local prêt vous aidera à suivre plus facilement.
Étape 1 – Créer un nouveau projet sur Back4App et se connecter
Créer un nouveau projet
La première étape pour créer un backend pour Elixir sur Back4App consiste à créer un nouveau projet. Si vous ne l'avez pas encore fait, suivez ces étapes :
Connectez-vous à votre compte Back4app.
Cliquez sur le bouton “Nouvelle application” dans votre tableau de bord Back4App.
Donnez un nom à votre application (par exemple, “Elixir-Backend-Tutorial”).
﻿
Une fois le projet créé, vous le verrez listé dans votre tableau de bord Back4App. Ce projet sera la base de toutes les configurations backend discutées dans ce tutoriel.
Connexion via REST ou GraphQL
Back4App utilise la plateforme Parse comme fondation. Pour Elixir, il n'existe pas de SDK Parse officiel pour le moment. Au lieu de cela, vous pouvez facilement vous connecter à Back4App en utilisant les API REST ou GraphQL. Dans votre projet Elixir, vous devrez :
Récupérer votre ID d'application et Clés REST ou GraphQL depuis la section “Paramètres de l'application” ou “Sécurité & Clés” dans le tableau de bord Back4App.
Configurer les requêtes HTTP en utilisant une bibliothèque Elixir telle que HTTPoison ou Tesla.
Par exemple, pour stocker des identifiants dans un fichier de configuration (config/dev.exs ou similaire) :
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"
﻿
Vous pouvez ensuite référencer ces identifiants dans votre code pour effectuer des appels REST. Tout au long de ce guide, nous allons montrer comment interagir avec la base de données Back4App, le système d'utilisateurs et d'autres fonctionnalités en utilisant des requêtes HTTP ou GraphQL standard.
Étape 2 – Configuration de la base de données
Créer un modèle de données
Dans Back4App, les données sont stockées dans des classes. Vous pouvez créer une nouvelle classe dans le tableau de bord Back4App :
Naviguez vers la section “Base de données” dans votre tableau de bord Back4App.
Créez une nouvelle classe (par exemple, “Todo”) et ajoutez des colonnes pertinentes, telles que titre (String) et estComplété (Boolean).
Créer une nouvelle classe
﻿
Créer un modèle de données en utilisant l'agent IA
Back4App fournit également un agent IA pour vous aider à décrire et créer votre modèle de données :
Ouvrez l'agent IA depuis votre tableau de bord d'application ou le menu.
Décrivez votre modèle de données en langage simple (par exemple, “Veuillez créer une nouvelle application Todo avec un schéma de classe complet.”).
Laissez l'agent IA créer le schéma automatiquement.
﻿
Lecture et écriture de données à l'aide du SDK (si applicable)
Puisqu'Elixir n'a pas de SDK Parse officiel, nous allons sauter l'utilisation directe du SDK. Au lieu de cela, nous allons présenter REST, GraphQL, et Live Queries approches ci-dessous.
Lecture et écriture de données à l'aide de l'API REST
Installez un client HTTP comme HTTPoison dans votre mix.exs:
Text
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
﻿
Ensuite, exécutez mix deps.get.
Pour créer (sauvegarder) un objet Todo depuis votre application 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
﻿
Et pour interroger vos objets 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
﻿
Lecture et écriture de données en utilisant l'API GraphQL
Vous pouvez également interagir via GraphQL. Par exemple, créer 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
    }
  }
}
﻿
En Elixir, vous pourriez également envoyer cela avec 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)
﻿
Travailler avec des requêtes en direct (optionnel)
Pour des mises à jour en temps réel, Back4App propose des requêtes en direct. Vous pouvez activer les requêtes en direct dans les Paramètres du serveur. Comme il n'existe pas de bibliothèque cliente Parse Elixir native pour le moment, vous vous connecterez généralement via un canal Phoenix ou tout client WebSocket personnalisé au wss://YOUR_SUBDOMAIN_HERE.b4a.io point de terminaison. Cela peut être plus avancé, nécessitant un codage personnalisé pour gérer les abonnements, les messages, etc.
Étape 3 – Application de la sécurité avec les ACL et les CLP
Aperçu rapide
Back4App propose des listes de contrôle d'accès (ACL) et des autorisations au niveau de la classe (CLP) pour protéger et gérer l'accès aux données. Les ACL s'appliquent à des objets individuels, tandis que les CLP s'appliquent à l'ensemble de la classe.
﻿
Étape par étape
Permissions au niveau de la classe (CLPs): Dans votre tableau de bord Back4App, sous Base de données, sélectionnez une classe (par exemple, “Todo”) et ouvrez l'onglet Permissions au niveau de la classe. Ajustez les paramètres (par exemple, “Nécessite une authentification” ou “Aucun accès” pour le public).
Configurer les ACL: Lors de la création ou de la mise à jour d'un objet, vous pouvez envoyer des données ACL dans votre requête REST ou GraphQL. Par exemple, spécifiez le champ _ACL en JSON si vous avez besoin d'un contrôle granulaire par objet.
Modifier les ACL
﻿
Pour plus d'informations, visitez les Directives de sécurité de l'application.
Étape 4 – Écriture des fonctions Cloud Code
Pourquoi Cloud Code
Le Cloud Code vous permet d'exécuter une logique côté serveur sans gérer vos propres serveurs. Avec Elixir, vous vous appuyez généralement sur OTP pour la concurrence, mais ici, vous pouvez simplement créer du Cloud Code JavaScript dans Back4App pour gérer la validation, les déclencheurs ou la logique métier personnalisée. Ce code s'exécute sur Parse Server, vous pouvez donc garder votre code Elixir concentré sur les tâches client ou microservice pendant que le travail lourd se fait dans le Cloud Code.
Fonction d'exemple
Dans votre main.js sur le tableau de bord Back4App ou en utilisant le 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 };
});
﻿
Déploiement
Déployez via le Back4app CLI ou en collant dans le tableau de bord sous Cloud Code > Functions et en cliquant sur Déployer.
﻿
Appel du Cloud Code
Depuis Elixir, vous pourriez utiliser :
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
﻿
Étape 5 – Configuration de l'authentification
Activer ou configurer l'authentification
Back4App utilise la classe User pour l'authentification. Vous pouvez gérer facilement l'inscription, la connexion et les réinitialisations de mot de passe. Depuis Elixir, vous utiliserez généralement des appels 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
﻿
Connexion sociale
Back4App prend en charge l'intégration avec Google, Apple, Facebook, et plus encore. Dans la plupart des cas, vous dirigerez les utilisateurs vers le flux OAuth, puis utiliserez les jetons retournés par ces fournisseurs pour compléter la connexion Parse. Voir Documentation sur la connexion sociale pour plus de détails.
Étape 6 – Gestion du stockage de fichiers
Configuration du stockage de fichiers
Back4App stocke les fichiers en toute sécurité. Depuis Elixir, vous pouvez télécharger des fichiers via 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
﻿
Vous recevrez une réponse JSON avec l'URL du fichier, que vous pouvez stocker dans une classe (par exemple, Photo) pour référence.
Considérations de sécurité
Vous pouvez configurer qui peut télécharger des fichiers dans les paramètres de fileUpload de votre projet Back4App, en restreignant les téléchargements aux utilisateurs authentifiés si vous le souhaitez.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
Aperçu
La vérification par e-mail garantit que les utilisateurs possèdent l'adresse e-mail utilisée lors de l'inscription. La réinitialisation du mot de passe leur permet de récupérer des comptes en toute sécurité. Les deux fonctionnalités sont intégrées sur Back4App.
Configuration du tableau de bord Back4App
Activer la vérification par e-mail dans les “Paramètres de l'application” ou “Authentification” de votre application.
Configurer le Adresse d'expédition et les modèles d'e-mail.
Activer la réinitialisation du mot de passe pour permettre aux utilisateurs de réinitialiser via un lien envoyé par e-mail.
Code/Implémentation
Une fois activée dans le tableau de bord, vous pouvez déclencher des réinitialisations de mot de passe :
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
﻿
Étape 8 – Planification des tâches avec des travaux Cloud
Quels emplois dans le cloud
Les emplois dans le cloud vous permettent d'automatiser des tâches routinières comme le nettoyage des anciennes données ou l'envoi d'e-mails périodiques. Vous les écrivez dans Cloud Code.
Exemple
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);
  }
});
﻿
Déployer le code.
Allez sur le tableau de bord Back4app > Paramètres de l'application > Paramètres du serveur > Emplois en arrière-plan.
Planifiez le travail pour qu'il s'exécute quotidiennement ou à une fréquence de votre choix.
Planification d'un emploi dans le cloud
﻿
Étape 9 – Intégration des Webhooks
Définition
Les webhooks permettent à votre application Back4App d'envoyer des requêtes HTTP à un service externe (par exemple, un canal Slack ou Stripe) lorsque certains événements se produisent.
Configuration
Accédez à la configuration des Webhooks dans votre tableau de bord Back4App > Plus > Webhooks.
Définissez le point de terminaison (par exemple, https://your-service.com/webhook-endpoint).
Configurez les déclencheurs tels que “Nouvel enregistrement dans la classe Todo.”
Ajout d'un Webhook
﻿
Exemple
Si vous souhaitez envoyer des données à Slack chaque fois qu'un Todo est créé, vous pouvez ajouter un nouveau webhook pointant vers votre URL de webhook entrant Slack. Vous pouvez également définir des Webhooks dans le Cloud Code en envoyant des requêtes HTTP personnalisées dans des déclencheurs comme afterSave.
WebHook BeforeSave
﻿
Étape 10 – Exploration du panneau d'administration Back4App
Où le trouver
L' Application d'administration Back4app est une interface conviviale pour gérer vos données. Vous pouvez l'activer depuis Tableau de bord de l'application > Plus > Application d'administration.
Activer l'application d'administration
﻿
Fonctionnalités
Créer un premier utilisateur administrateur, ce qui configure le rôle B4aAdminUser et des classes supplémentaires.
Attribuer un sous-domaine pour accéder à l'interface d'administration.
Se connecter pour visualiser et gérer les données dans une interface simple.
﻿
Conclusion
En suivant ce tutoriel sur la façon de construire un backend pour Elixir avec Back4App, vous avez :
Créé une backend sécurisé sur la plateforme de Back4App en utilisant Elixir pour l'intégration.
Mis en place une base de données avec des classes, des types de données et des relations.
Utilisé REST/GraphQL pour interagir avec vos données depuis Elixir.
Appliqué la sécurité en utilisant des ACL et des CLP.
Ajouté une logique personnalisée avec des fonctions Cloud Code.
Configuré l'authentification des utilisateurs avec vérification par e-mail et réinitialisation de mot de passe.
Géré le stockage de fichiers et la récupération.
Planifié des tâches en arrière-plan pour l'automatisation.
Intégré des services externes avec des webhooks.
Exploré le panneau d'administration de Back4App pour une gestion facile des données.
Avec le modèle de concurrence d'Elixir (alimenté par l'Erlang VM) et OTP, combiné avec les services évolutifs et flexibles de Back4App, vous pouvez construire des backends très robustes.
Continuez à explorer des fonctionnalités plus avancées, intégrez votre logique métier, et laissez Back4App vous aider à gérer le travail lourd.
Prochaines étapes
Construire une application Elixir prête pour la production en superposant ce backend avec votre framework web Elixir/Phoenix préféré.
Intégrer des fonctionnalités avancées comme le contrôle d'accès basé sur les rôles ou des API tierces (passerelles de paiement, services de messagerie).
Explorer la documentation officielle de Back4app pour la sécurité avancée, les journaux, l'optimisation des performances, et plus encore.
Consulter d'autres tutoriels pour des applications en temps réel, des tableaux de bord IoT, ou des services basés sur la localisation. Avec le pattern matching et la concurrence OTP à votre disposition, vous êtes équipé pour aborder une large gamme d'applications!
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Ruby ?
Comment construire un backend pour le framework Play ?