Quickstarters
Comment construire un backend pour Golang ?

36min
Introduction
Dans ce tutoriel, vous apprendrez à construire et tester un backend complet pour Golang en utilisant Back4App. 
Nous vous guiderons à travers l'intégration des fonctionnalités essentielles de Back4App—telles que la gestion de base de données, les paramètres de sécurité, l'authentification des utilisateurs, le stockage de fichiers et le Cloud Code—pour créer un backend sécurisé, flexible et évolutif qui fonctionne bien avec votre serveur http Go. 
Notre objectif sera d'utiliser les API RESTful de Back4App pour se connecter à la base de données depuis notre client http Golang, plutôt qu'un SDK Parse dédié, afin d'illustrer comment construire des fonctions de gestion faciles à maintenir pour votre nouveau backend.
Vous verrez comment cette approche réduit la complexité du développement par rapport à la configuration de vos propres serveurs à partir de zéro. 
En vous appuyant sur les requêtes en temps réel de Back4App, le stockage de fichiers et les systèmes d'authentification des utilisateurs, vous accélérerez votre processus de création de backend. 
À la fin, vous saurez comment construire un backend Golang sécurisé, planifier des tâches automatisées et intégrer des webhooks externes. 
Vous serez bien préparé à améliorer cette base en une application prête pour la production ou à ajouter une logique personnalisée si nécessaire.
Prérequis
Un compte Back4App
Inscrivez-vous gratuitement ici.
Un nouveau projet Back4App
Commencer avec Back4app﻿
Environnement de développement Go (Golang)
Assurez-vous d'avoir Go installé sur votre machine. Vous pouvez trouver des instructions dans la Documentation officielle de Go.
Connaissances de base du package http de Go et des API RESTful
Une familiarité avec la façon d'écrire un gestionnaire de fonction, de parser les messages d'erreur, de gérer les requêtes de méthode POST et de configurer un serveur http localhost sera utile.
Assurez-vous d'avoir ces prérequis en place avant de continuer. Cette configuration facilitera votre expérience alors que vous découvrirez comment construire un backend pour Golang en utilisant Back4App.
Étape 1 – Création d'un nouveau projet sur Back4App et connexion
Pourquoi un nouveau projet ?
Créer un nouveau projet Back4App est votre première étape. C'est là que vous stockerez des données, configurerez le stockage de fichiers, programmerez des fonctions cloud et ajouterez des tâches en arrière-plan. Ce projet backend ancrera toutes les étapes suivantes.
Connectez-vous à votre compte Back4App.
Cliquez sur “Nouvelle application” dans votre tableau de bord Back4App.
Nommez votre application (par exemple, “Golang-Backend-Tutorial”).
﻿
Une fois créée, elle apparaîtra dans votre tableau de bord. Cette application est maintenant votre backend basé sur Back4App.
Connexion via les API REST
Back4App fournit des API RESTful pour créer, mettre à jour et supprimer des données. En Golang, nous utiliserons le client http de la bibliothèque standard de Go pour communiquer avec ces points de terminaison.
Localisez votre ID d'application et clé API REST en allant dans la section Paramètres ou Sécurité et clés de votre application Back4App :
﻿
Vous aurez besoin de ces identifiants dans chaque en-tête de requête. Nous illustrerons cela dans les étapes suivantes lorsque nous nous connecterons à la base de données en utilisant les méthodes POST, GET et d'autres requêtes HTTP.
Étape 2 – Configuration de la base de données
Création d'un modèle de données
Pour stocker des données dans Back4App, vous définissez des classes (tables) et des colonnes (champs). Par exemple, disons que nous voulons une Todo classe. Vous pouvez la créer manuellement dans le tableau de bord de Back4App :
Allez dans la section Base de données de votre tableau de bord d'application.
Créez une nouvelle classe nommée “Todo.”
Ajoutez des colonnes telles que titre (String) et isCompleted (Boolean).
Créer une nouvelle classe
﻿
Vous pouvez également laisser le système créer automatiquement des colonnes en envoyant des objets avec de nouveaux champs depuis votre application Golang.
Créer 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 souhaité (par exemple, “Veuillez créer une nouvelle classe Todo avec un champ titre et un champ isCompleted.”).
Acceptez le schéma suggéré.
﻿
Cette fonctionnalité pratique fait gagner du temps dans la conception de votre schéma de base de données.
Lecture et écriture de données en utilisant l'API REST (Exemple Golang)
Voici un exemple de base de la façon de créer (méthode POST) et de récupérer (méthode GET) des données en utilisant le package http de Go. Supposons que vous ayez votre APPLICATION_ID et REST_API_KEY comme variables d'environnement.
Go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

type Todo struct {
    ObjectID    string `json:"objectId,omitempty"`
    Title       string `json:"title,omitempty"`
    IsCompleted bool   `json:"isCompleted,omitempty"`
}

func main() {
    // Example: Create Todo
    newTodo := Todo{
        Title:       "Buy groceries",
        IsCompleted: false,
    }
    created, err := createTodo(newTodo)
    if err != nil {
        log.Println("Error creating todo:", err)
    } else {
        log.Println("Created todo with ID:", created.ObjectID)
    }

    // Example: Fetch Todos
    todos, err := fetchAllTodos()
    if err != nil {
        log.Println("Error fetching todos:", err)
    } else {
        for _, t := range todos {
            log.Println("Fetched todo:", t.Title, t.IsCompleted)
        }
    }
}

// createTodo sends a POST request to save a new record in the "Todo" class.
func createTodo(todo Todo) (Todo, error) {
    // Convert struct to JSON
    body, _ := json.Marshal(todo)

    // Create HTTP request
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/classes/Todo", bytes.NewBuffer(body))
    if err != nil {
        return Todo{}, err
    }

    // Set necessary headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    // Execute the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return Todo{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return Todo{}, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response
    var createdTodo Todo
    if err := json.NewDecoder(resp.Body).Decode(&createdTodo); err != nil {
        return Todo{}, err
    }

    return createdTodo, nil
}

// fetchAllTodos retrieves all Todo objects from Back4App using GET
func fetchAllTodos() ([]Todo, error) {
    req, err := http.NewRequest("GET", "https://parseapi.back4app.com/classes/Todo", nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response for "results" key
    var result struct {
        Results []Todo `json:"results"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    return result.Results, nil
}
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

type Todo struct {
    ObjectID    string `json:"objectId,omitempty"`
    Title       string `json:"title,omitempty"`
    IsCompleted bool   `json:"isCompleted,omitempty"`
}

func main() {
    // Example: Create Todo
    newTodo := Todo{
        Title:       "Buy groceries",
        IsCompleted: false,
    }
    created, err := createTodo(newTodo)
    if err != nil {
        log.Println("Error creating todo:", err)
    } else {
        log.Println("Created todo with ID:", created.ObjectID)
    }

    // Example: Fetch Todos
    todos, err := fetchAllTodos()
    if err != nil {
        log.Println("Error fetching todos:", err)
    } else {
        for _, t := range todos {
            log.Println("Fetched todo:", t.Title, t.IsCompleted)
        }
    }
}

// createTodo sends a POST request to save a new record in the "Todo" class.
func createTodo(todo Todo) (Todo, error) {
    // Convert struct to JSON
    body, _ := json.Marshal(todo)

    // Create HTTP request
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/classes/Todo", bytes.NewBuffer(body))
    if err != nil {
        return Todo{}, err
    }

    // Set necessary headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    // Execute the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return Todo{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return Todo{}, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response
    var createdTodo Todo
    if err := json.NewDecoder(resp.Body).Decode(&createdTodo); err != nil {
        return Todo{}, err
    }

    return createdTodo, nil
}

// fetchAllTodos retrieves all Todo objects from Back4App using GET
func fetchAllTodos() ([]Todo, error) {
    req, err := http.NewRequest("GET", "https://parseapi.back4app.com/classes/Todo", nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response for "results" key
    var result struct {
        Results []Todo `json:"results"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    return result.Results, nil
}
﻿
Dans ces exemples, nous créons un client http, ajoutons les en-têtes nécessaires et gérons les codes de réponse ainsi que les messages d'erreur. N'oubliez pas de remplacer YOUR_APPLICATION_ID et YOUR_REST_API_KEY par les clés réelles de votre projet Back4App.
Lecture et écriture de données en utilisant l'API GraphQL
Back4App fournit également un point de terminaison GraphQL à https://parseapi.back4app.com/graphql. Vous pouvez utiliser une bibliothèque cliente Go GraphQL populaire (comme Machine Box graphql) pour effectuer des requêtes ou des mutations. Cela peut être une approche plus structurée que les appels REST bruts.
Travailler avec des requêtes en direct (optionnel)
Si vous souhaitez voir des mises à jour en temps réel dans votre application, vous pouvez activer les requêtes en direct dans le tableau de bord Back4App. Golang n'a pas de bibliothèque officielle pour les requêtes en direct Parse. Cependant, vous pouvez implémenter votre propre connexion websocket pour écouter les mises à jour des requêtes en direct depuis wss://YOUR_SUBDOMAIN.b4a.io. Cette fonctionnalité est utile pour les applications collaboratives nécessitant une synchronisation immédiate des données.
Étape 3 – Application de la sécurité avec les ACL et les CLP
Aperçu
Back4App fournit des listes de contrôle d'accès (ACL) et des autorisations au niveau de la classe (CLP) pour protéger vos données. Les ACL sont définies sur chaque objet, tandis que les CLP définissent des règles générales pour une classe entière.
﻿
Autorisations au niveau de la classe
Allez dans la base de données de votre application dans Back4App.
Sélectionnez une classe (par exemple, Todo).
Cliquez sur Autorisations au niveau de la classe et définissez l'accès en lecture/écriture pour différents rôles d'utilisateur ou l'accès public.
﻿
ACL
Vous pouvez passer une ACL lors de la création ou de la mise à jour d'un objet via des appels REST. Cela garantit que seuls certains utilisateurs ou rôles peuvent lire/écrire les données. Pour plus de détails, visitez les directives de sécurité de l'application.
Étape 4 – Écriture de fonctions Cloud Code
Pourquoi Cloud Code
Le Cloud Code vous permet d'exécuter des fonctions côté serveur, des déclencheurs ou des validations—sans gérer vos propres serveurs. Vous pouvez ajouter une logique métier avancée ou intégrer des API externes depuis le côté serveur.
Exemple de fonction Cloud
Un exemple simple est une fonction qui calcule la longueur du texte. Dans votre main.js fichier sur le tableau de bord Back4App :
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 };
});
﻿
Déploiement
Déployez Cloud Code en utilisant :
Back4App CLI:
Back4App Dashboard sous Cloud Code > Functions. Collez votre code dans l'éditeur main.js et cliquez sur Déployer.
﻿
Appel des fonctions Cloud depuis Golang
Vous pouvez appeler une fonction Cloud via REST depuis votre client http :
Go
func callCalculateTextLength(txt string) (int, error) {
    body, _ := json.Marshal(map[string]string{"text": txt})
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/functions/calculateTextLength", bytes.NewBuffer(body))
    if err != nil {
        return 0, err
    }

    // Headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return 0, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    var result struct {
        Result map[string]int `json:"result"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return 0, err
    }

    return result.Result["length"], nil
}
func callCalculateTextLength(txt string) (int, error) {
    body, _ := json.Marshal(map[string]string{"text": txt})
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/functions/calculateTextLength", bytes.NewBuffer(body))
    if err != nil {
        return 0, err
    }

    // Headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return 0, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    var result struct {
        Result map[string]int `json:"result"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return 0, err
    }

    return result.Result["length"], nil
}
﻿
Étape 5 – Configuration de l'authentification
Activer l'authentification des utilisateurs
Back4App utilise une classe Utilisateur pour l'authentification. Lorsque vous créez un nouvel utilisateur via REST, le backend stockera les identifiants de manière sécurisée et générera un jeton de session.
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": "alice", "password": "secret123", "email": "[email protected]"}' \
  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": "alice", "password": "secret123", "email": "alice@example.com"}' \
  https://parseapi.back4app.com/users
﻿
Utilisez le jeton de session retourné pour les requêtes ultérieures nécessitant des privilèges utilisateur. En Go, vous enverriez le même type de requête HTTP depuis un client http comme démontré précédemment.
Connexion sociale
Pour les connexions sociales comme Google ou Facebook, vous devrez configurer les paramètres OAuth sur Back4App. Ces flux impliquent souvent l'échange de jetons. Consultez la Documentation de connexion avec Apple / Connexion sociale pour plus de détails.
Étape 6 – Gestion du stockage de fichiers
Configuration et téléchargement
Vous pouvez stocker des fichiers sur Back4App en les envoyant sous forme de données encodées en base64 ou de multipart/form-data :
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 '{
    "file": {
      "name": "myImage.png",
      "__type": "File",
      "base64": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  }' \
  https://parseapi.back4app.com/files/myImage.png
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 '{
    "file": {
      "name": "myImage.png",
      "__type": "File",
      "base64": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  }' \
  https://parseapi.back4app.com/files/myImage.png
﻿
Après le téléchargement, vous pouvez attacher le fichier à un objet en stockant l'URL du fichier retourné ou le pointeur du fichier. En Go, créez une requête http de la même manière—assurez-vous simplement d'encoder correctement le contenu du fichier.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
Importance
La vérification par e-mail garantit que les utilisateurs contrôlent l'e-mail fourni, tandis que la réinitialisation du mot de passe les aide à récupérer leurs comptes. Les deux fonctionnalités renforcent la sécurité et la confiance.
Activation de la vérification par e-mail
Allez sur votre Tableau de bord Back4App.
Sous Paramètres de messagerie, activez les e-mails de vérification.
Personnalisez vos modèles d'e-mail si nécessaire.
Lorsqu'un utilisateur s'inscrit, un e-mail de vérification est automatiquement envoyé.
Réinitialisation du mot de passe
Utilisez le point de terminaison REST requestPasswordReset pour initier 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
﻿
Étape 8 – Planification des tâches avec les Cloud Jobs
Ce que font les Cloud Jobs
Les Cloud Jobs s'exécutent selon un calendrier pour automatiser des tâches comme le nettoyage des données obsolètes ou l'envoi de bulletins d'information hebdomadaires.
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  // Remove records older than 30 days
  // ...
});
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  // Remove records older than 30 days
  // ...
});
﻿
Déployez ce job et planifiez-le dans votre Tableau de bord Back4App > Paramètres de l'application > Paramètres du serveur > Tâches d'arrière-plan.
﻿
Étape 9 – Intégration des Webhooks
Pourquoi les Webhooks
Les Webhooks vous permettent de notifier des services externes lorsque certains événements se produisent. Par exemple, vous pourriez envoyer des alertes Slack lorsque de nouveaux éléments Todo sont créés.
Allez à la section des Webhooks dans votre Tableau de bord Back4App.
Configurez votre point de terminaison (comme https://your-external-service.com/webhook).
Assignez des déclencheurs (par exemple, afterSave sur Todo).
Ajout d'un Webhook
﻿
Vous pouvez également déclencher des API externes depuis le Cloud Code en écrivant une requête http client si vous préférez un contrôle direct des événements.
Étape 10 – Exploration du panneau d'administration Back4App
Aperçu
L'application Admin Back4App est une interface point-and-click que vous pouvez partager avec des membres de l'équipe non techniques pour gérer les données.
Activer l'application Admin
Allez à Plus > Application Admin dans votre tableau de bord Back4App.
Activez-le et créez un utilisateur admin.
Activer l'application Admin
﻿
Utilisez votre sous-domaine choisi pour vous connecter à une interface utilisateur simple pour la manipulation des données. Cela vous libère de l'écriture de requêtes directes ou de code personnalisé pour effectuer des opérations de base.
Conclusion
Dans ce guide, vous avez découvert comment construire un backend pour Golang en utilisant Back4App. 
Vous avez exploré comment vous connecter à la base de données via des API RESTful, appliquer des mesures de sécurité avec des ACL et des CLP, exécuter des tâches planifiées avec des Cloud Jobs, intégrer des services externes à l'aide de Webhooks, et configurer l'authentification des utilisateurs et le stockage de fichiers.
Avec le package http de Go et les fonctionnalités robustes de Back4App, vous pouvez créer un backend puissant qui fait gagner du temps et évolue sans effort. 
Maintenant que vous avez maîtrisé les bases, vous pouvez étendre la logique de votre fonction de gestionnaire Golang, vous connecter à de nouveaux points de terminaison API et construire une application riche qui répond à vos besoins.
Prochaines étapes
Affinez votre application Golang: Ajoutez des fonctionnalités avancées comme l'accès basé sur les rôles, ou optimisez votre serveur http pour la production.
En savoir plus sur les requêtes en temps réel: Intégrez des requêtes en direct pour des applications collaboratives.
Explorez la documentation avancée de Back4App: Affinez vos ACL, journaux et analyses.
Incorporez des API tierces: Utilisez le Cloud Code ou des webhooks directs pour étendre la fonctionnalité de votre backend.
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Deno ?
Comment construire un backend pour Symfony ?