Quickstarters
Comment construire un backend pour Ruby ?

36min
Introduction
Dans ce tutoriel, vous découvrirez comment construire un backend pour Ruby en utilisant Back4App. 
Nous passerons en revue les 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). 
En tirant parti du langage de programmation Ruby et de Back4App, vous obtenez un backend sécurisé, évolutif et robuste qui s'intègre facilement à votre écosystème de développement logiciel.
Cette approche permet de gagner du temps et des efforts en utilisant une plateforme web open source construite sur Parse. Vous verrez comment accélérer les projets de développement avec des principes de développement rapide. 
En cours de route, vous apprendrez à utiliser des fonctionnalités de sécurité avancées, à planifier des tâches avec Cloud Jobs et à configurer des webhooks pour des intégrations externes. 
À la fin, vous serez prêt à créer une structure de framework d'application web et à l'étendre pour des applications de production.
Vous pourrez :
Intégrer Ruby avec Back4App pour des modèles de données, une logique orientée objet et des données en temps réel.
Tirer parti des meilleures pratiques du processus de développement pour le développement d'applications dans un style modèle-vue-contrôleur (MVC) ou toute autre architecture de votre choix.
Améliorer votre rôle en tant que développeur backend en gérant l'authentification sécurisée des utilisateurs, les déclencheurs de Cloud Code, et plus encore.
Affiner davantage vos applications web pour répondre aux besoins du monde réel en utilisant les fonctionnalités flexibles de Back4App.
Prérequis
Un compte Back4app et un nouveau projet Back4app
Commencer avec Back4app.
Inscrivez-vous gratuitement si vous n'avez pas de compte.
Un environnement Ruby local
Vous devez avoir Ruby installé. En général, Ruby 2.6 ou supérieur est recommandé.
Familiarité avec le langage de programmation Ruby
Connaissances de base de la syntaxe Ruby, des concepts orientés objet et de l'utilisation courante des langages de programmation
Bundler (optionnel mais recommandé)
Bundler aide à gérer les gems pour votre framework d'application web ou vos projets de développement. Documentation officielle de Bundler.﻿
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4App créé et votre environnement Ruby prêt vous offrira une expérience de tutoriel fluide.
Étape 1 – Créer un nouveau projet sur Back4App et se connecter
Pourquoi cette étape est importante
Un nouveau projet Back4App est la base de votre développement d'application. Il héberge votre base de données, gère l'authentification des utilisateurs et fournit l'environnement pour exécuter Cloud Code.
Créer un nouveau projet
Connectez-vous à Back4App.
Cliquez sur Nouvelle application dans votre tableau de bord Back4App.
Donnez un nom à votre application (par exemple, “Ruby-Backend-Tutorial”).
Installer Parse SDK et se connecter à Back4App
Le Parse SDK pour Ruby vous aide à interagir avec le backend de Back4App. Vous pouvez l'installer via gem:
Étape 2 – Configuration de la base de données
1. Création d'un modèle de données
Dans Back4App, une classe est comme une table de base de données. Par exemple, vous pouvez créer une classe “Todo” pour stocker des tâches. Vous pouvez créer des classes à la volée depuis Ruby ou les définir dans le tableau de bord pour un contrôle précis.
2. Création d'un modèle de données en utilisant l'agent IA
Ouvrez l'agent IA dans votre tableau de bord d'application.
Décrivez votre modèle de données en langage simple (par exemple, “Une application Todo avec des champs titre, isCompleted”).
Laissez l'agent IA créer votre schéma automatiquement.
﻿
3. Lecture et écriture de données en utilisant Ruby (Parse SDK)
Voici un exemple simple de création d'un nouvel enregistrement dans une classe “Todo” en utilisant le SDK Ruby :
Ruby
require_relative 'parse_config'

# Create a Todo object
todo = Parse::Object.new("Todo")
todo["title"] = "Buy groceries"
todo["isCompleted"] = false
saved_todo = todo.save
puts "Todo saved with objectId: #{saved_todo['objectId']}"

# Query Todos
query = Parse::Query.new("Todo")
results = query.get
puts "Fetched #{results.size} todos."
results.each do |t|
  puts "Title: #{t['title']}, Completed: #{t['isCompleted']}"
end
require_relative 'parse_config'

# Create a Todo object
todo = Parse::Object.new("Todo")
todo["title"] = "Buy groceries"
todo["isCompleted"] = false
saved_todo = todo.save
puts "Todo saved with objectId: #{saved_todo['objectId']}"

# Query Todos
query = Parse::Query.new("Todo")
results = query.get
puts "Fetched #{results.size} todos."
results.each do |t|
  puts "Title: #{t['title']}, Completed: #{t['isCompleted']}"
end
﻿
4. Lecture et écriture de données en utilisant l'API REST
Vous pouvez également créer et récupérer des enregistrements en utilisant l'interface REST :
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": "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
﻿
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": "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
﻿
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": "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
﻿
5. Lecture et écriture de données en utilisant l'API GraphQL
Back4App offre un point de terminaison GraphQL pour des applications web:
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
    }
  }
}
﻿
6. Travailler avec des requêtes en direct (Optionnel)
Activez les requêtes en direct dans le tableau de bord Back4App (Paramètres du serveur) et abonnez-vous depuis votre script Ruby si votre environnement prend en charge les connexions WebSocket. Vous pouvez également les utiliser pour des mises à jour en temps réel dans un framework d'application web qui prend en charge la concurrence.
Étape 3 – Application de la sécurité avec les ACL et les CLP
1. Vue d'ensemble
Les ACL (Listes de contrôle d'accès) et les CLP (Permissions au niveau de la classe) protègent vos données de manière orientée objet. Les ACL vous permettent de décider qui peut lire ou écrire chaque enregistrement. Les CLP vous permettent de gérer les permissions pour une classe entière.
﻿
2. Définir les permissions au niveau de la classe (CLP) et les ACL
Allez dans la base de données de votre application et sélectionnez votre classe, comme “Todo.” Configurez les CLP de votre classe sous “Sécurité” ou “Permissions au niveau de la classe.” Pour définir des ACL sur un enregistrement :
Ruby
owner = Parse::User.current
todo = Parse::Object.new("Todo")
acl = Parse::ACL.new(owner)
acl.public_read = false
acl.public_write = false
todo.acl = acl
todo["title"] = "Private Task"
todo.save
owner = Parse::User.current
todo = Parse::Object.new("Todo")
acl = Parse::ACL.new(owner)
acl.public_read = false
acl.public_write = false
todo.acl = acl
todo["title"] = "Private Task"
todo.save
﻿
Cela garantit que seul le propriétaire peut lire/écrire cette tâche Todo particulière.
Étape 4 – Écriture de fonctions Cloud Code
1. Pourquoi Cloud Code
Cloud Code aide à intégrer la logique métier et les validations directement dans le serveur. C'est idéal pour garantir l'intégrité des données et effectuer des tâches non exposées aux clients.
2. Exemple de fonction
Dans le main.js de votre projet (ou similaire) sur Back4App, vous pouvez définir une fonction Cloud :
JS
Parse.Cloud.define('calculateTextLength', (request) => {
  const { text } = request.params;
  if (!text) {
    throw 'No text provided';
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', (request) => {
  const { text } = request.params;
  if (!text) {
    throw 'No text provided';
  }
  return { length: text.length };
});
﻿
Remarque : Bien que notre application principale utilise Ruby, Cloud Code dans Parse est basé sur JavaScript. C'est ainsi que vous intégrez la logique côté serveur sur Back4App.
3. Déploiement
Back4App CLI:
Tableau de bord Back4App: Copiez/collez votre fonction dans Cloud Code > Fonctions et cliquez sur Déployer.
4. Modules NPM
Vous pouvez installer des modules npm (par exemple, axios) pour votre environnement Cloud Code. Par exemple :
Bash
npm install axios
npm install axios
﻿
Dans votre main.js, incluez-le et effectuez des appels API externes selon les besoins.
Étape 5 – Configuration de l'authentification
1. Paramètres du tableau de bord
Activez l'authentification des utilisateurs dans les Paramètres de l'application. Back4App utilise Parse.User pour la gestion des utilisateurs.
2. Inscription / Connexion avec Ruby
Ruby
require_relative 'parse_config'

# Signing Up a User
user = Parse::User.new({
  username: "alice",
  password: "secret123",
  email: "[email protected]"
})
begin
  user.sign_up
  puts "User signed up successfully"
rescue => e
  puts "Error: #{e.message}"
end

# Logging In a User
logged_in_user = Parse::User.login("alice", "secret123")
puts "Logged in as: #{logged_in_user.username}"
require_relative 'parse_config'

# Signing Up a User
user = Parse::User.new({
  username: "alice",
  password: "secret123",
  email: "alice@example.com"
})
begin
  user.sign_up
  puts "User signed up successfully"
rescue => e
  puts "Error: #{e.message}"
end

# Logging In a User
logged_in_user = Parse::User.login("alice", "secret123")
puts "Logged in as: #{logged_in_user.username}"
﻿
3. Connexion sociale
Pour intégrer des connexions sociales (Facebook, Google, Apple), consultez les Documents de connexion sociale. Les détails de mise en œuvre varient selon chaque fournisseur.
Étape 6 – Gestion du stockage de fichiers
1. Configuration du stockage de fichiers
Back4App gère les téléchargements de fichiers via l'objet Parse::File. En Ruby:
Ruby
file = Parse::File.new("image.png", File.read("/path/to/image.png"))
saved_file = file.save
puts "File saved at: #{saved_file.url}"

# Attach file to an object
photo = Parse::Object.new("Photo")
photo["imageFile"] = saved_file
photo.save
puts "Photo object created with file reference."
file = Parse::File.new("image.png", File.read("/path/to/image.png"))
saved_file = file.save
puts "File saved at: #{saved_file.url}"

# Attach file to an object
photo = Parse::Object.new("Photo")
photo["imageFile"] = saved_file
photo.save
puts "Photo object created with file reference."
﻿
2. Exemple
Les utilisateurs peuvent télécharger des images, des documents ou d'autres fichiers. Récupérez l'URL pour l'afficher dans votre frontend ou d'autres services.
3. Considérations de sécurité
Configurez votre application pour restreindre les téléchargements de fichiers aux utilisateurs authentifiés si nécessaire.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
1. Pourquoi c'est important
La vérification par e-mail garantit des adresses e-mail valides pour les nouveaux comptes. La réinitialisation du mot de passe permet à vos utilisateurs de récupérer leurs comptes en toute sécurité.
2. Configuration du tableau de bord Back4App
Activer Vérification par e-mail.
Configurer des modèles personnalisés pour la vérification et la réinitialisation du mot de passe.
3. Exemple de code
Depuis Ruby, vous pouvez demander une réinitialisation de mot de passe :
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 '{"email": "[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
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 '{"email": "alice@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Cela envoie un lien de réinitialisation de mot de passe à l'e-mail de l'utilisateur.
Étape 8 – Planification des tâches avec les Cloud Jobs
1. Ce que font les Cloud Jobs
Les travaux Cloud exécutent des tâches périodiques comme le nettoyage des anciennes données ou l'envoi d'e-mails récapitulatifs.
2. Exemple de travail
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);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
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);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Planifiez-le sous Paramètres de l'application > Paramètres du serveur > Travaux en arrière-plan dans votre tableau de bord Back4App.
Étape 9 – Intégration des Webhooks
1. Définition
Les Webhooks vous permettent d'envoyer des requêtes HTTP à des services externes chaque fois que certains événements se produisent dans Back4App. C'est idéal pour se connecter à des services tiers ou déclencher des tâches dans d'autres langages de programmation.
2. Configuration
Allez dans le tableau de bord Back4App de votre application > Plus > WebHooks, et ajoutez un nouveau Webhook avec l'URL de votre service externe.
3. Exemple
Envoyez des données à Stripe ou Slack chaque fois qu'un nouveau “Todo” est créé. Alternativement, vous pouvez définir des déclencheurs dans le code Cloud et effectuer des requêtes HTTP dans ces déclencheurs.
Étape 10 – Exploration du panneau d'administration Back4App
1. Où le trouver
Dans le tableau de bord de votre application, cliquez sur Plus > Application Admin, puis activez-le.
2. Fonctionnalités
Interface graphique pour la gestion des données sans code.
Outils pour analyser les journaux, planifier des tâches en arrière-plan, et plus.
Contrôle d'accès basé sur les rôles, vous permettant de fournir aux utilisateurs non techniques un moyen sûr de gérer le contenu.
Activer l'application Admin
﻿
Conclusion
Vous avez construit un backend sécurisé et évolutif pour votre application Ruby sur Back4App, en utilisant le langage de programmation Ruby pour vous connecter à l'API Parse. Votre processus de développement comprend maintenant :
Une base de données avec des fonctionnalités de sécurité avancées (ACL, CLP).
Mises à jour de données en temps réel via des requêtes en direct.
Déclencheurs de Cloud Code pour une logique métier personnalisée.
Authentification des utilisateurs et gestion des fichiers.
Tâches planifiées avec des Cloud Jobs et des Webhooks pour des services externes.
Un Panneau d'administration convivial pour la gestion des données.
Avec cette base, vous pouvez étendre vos applications web ou d'autres projets de langages de programmation pour répondre aux exigences du monde réel.
Que vous soyez un développeur backend expérimenté ou que vous commenciez tout juste avec Ruby, Back4App offre une plateforme orientée objet et facile à utiliser pour un développement rapide.
N'hésitez pas à intégrer des API ou des fonctionnalités supplémentaires, et explorez d'autres personnalisations pour vous aligner sur les modèles de contrôleur de vue de modèle (MVC) ou d'autres styles architecturaux.
Prochaines étapes
Affinez votre environnement de production en ajoutant un cache avancé, un accès basé sur des rôles ou des optimisations de performance.
Ajoutez des relations plus complexes entre les classes de données pour alimenter des cas d'utilisation réels.
Explorez la documentation officielle de Back4App pour la sécurité, les informations sur la performance et l'analyse.
Expérimentez avec d'autres frameworks web open source pour étendre les fonctionnalités de votre application.
Profitez de la construction d'applications web plus robustes et riches en fonctionnalités avec Ruby et Back4App!
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Ruby On Rails ?
Comment construire un backend pour Elixir ?