Go et MongoDB : créer une API CRUD à partir de zéro

Vous souhaitez créer une application Web dynamique avec un backend robuste ? Ne cherchez pas plus loin que Go et MongoDB ! Cette combinaison puissante vous permet de créer des API évolutives et efficaces qui gèrent facilement la création, la lecture, la mise à jour et la suppression (CRUD) de données.

Dans ce guide convivial pour les débutants, nous expliquerons le processus de création d'une API CRUD simple à l'aide de Go et MongoDB. Nous couvrirons les étapes essentielles, fournirons des exemples de code et parsèmerons de conseils utiles en cours de route.

Commencer

Tout d'abord, configurons notre environnement :

1. Installation de Go : Téléchargez et installez la dernière version de Go depuis https://go.dev/dl/.
2. Configuration de MongoDB : Si MongoDB n'est pas en cours d'exécution, vous pouvez le télécharger et l'installer à partir de https://www.mongodb.com/try/download/community.
3. IDE ou éditeur de texte : Choisissez votre environnement de codage préféré. Certaines options populaires incluent VS Code, GoLand ou Atom.

Structure du projet :

Créez un nouveau répertoire de projet et organisez vos fichiers comme ceci :

my-crud-api/
├── main.go
├── models/
│   └── user.go
├── handlers/
│   └── user.go
└── config/
    └── config.go

Définir notre modèle

Commençons par définir notre modèle de données. Pour cet exemple, nous allons créer une simple structure User :

// models/user.go
package models

import (
    "go.mongodb.org/mongo-driver/bson/primitive"
)

type User struct {
    ID     primitive.ObjectID `bson:"_id,omitempty"`
    Name   string             `bson:"name,omitempty"`
    Email  string             `bson:"email,omitempty"`
    Age    int                `bson:"age,omitempty"`
    Active bool               `bson:"active,omitempty"`
}

Explication :

• Nous utilisons primitive.ObjectID du package mongo-driver pour représenter l'ID unique du document MongoDB.
• Les balises bson sont cruciales pour mapper nos champs de structure Go aux champs correspondants dans nos documents MongoDB.

Connexion à MongoDB

Nous devons établir une connexion à notre base de données MongoDB. Créez un fichier config.go dans le répertoire config :

// config/config.go
package config

import (
    "context"
    "fmt"
    "os"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func ConnectToMongoDB() (*mongo.Client, error) {
    uri := os.Getenv("MONGODB_URI")
    if uri == "" {
        return nil, fmt.Errorf("MONGODB_URI is not set")
    }

    clientOptions := options.Client().ApplyURI(uri)
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Ping(context.Background(), nil)
    if err != nil {
        return nil, err
    }

    return client, nil
}

Explication :

• Nous utilisons os.Getenv pour récupérer l'URI de connexion MongoDB à partir de la variable d'environnement MONGODB_URI. Assurez-vous de définir cette variable dans votre environnement.
• Nous utilisons le package mongo-driver pour nous connecter à la base de données MongoDB et effectuer des opérations de base comme envoyer un ping à la base de données.

Gestionnaires de bâtiments

Maintenant, construisons les gestionnaires d'API pour nos opérations CRUD. Dans le répertoire des gestionnaires, créez un fichier user.go :

// handlers/user.go
package handlers

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/your-username/my-crud-api/config"
    "github.com/your-username/my-crud-api/models"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
)

// Create a new user
func CreateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    var user models.User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.InsertOne(context.Background(), user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Get all users
func GetAllUsers(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    collection := client.Database("your_database_name").Collection("users")
    cursor, err := collection.Find(context.Background(), bson.D{})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer cursor.Close(context.Background())

    var users []models.User
    for cursor.Next(context.Background()) {
        var user models.User
        if err := cursor.Decode(&user); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        users = append(users, user)
    }

    json.NewEncoder(w).Encode(users)
}

// Get a user by ID
func GetUserByID(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    var user models.User
    if err := collection.FindOne(context.Background(), bson.M{"_id": id}).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    json.NewEncoder(w).Encode(user)
}

// Update a user
func UpdateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    var updatedUser models.User
    if err := json.NewDecoder(r.Body).Decode(&updatedUser); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    filter := bson.M{"_id": id}
    update := bson.M{"$set": updatedUser}
    result, err := collection.UpdateOne(context.Background(), filter, update)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Delete a user
func DeleteUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.DeleteOne(context.Background(), bson.M{"_id": id})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

Explication :

• Nous implémentons les opérations CRUD : CreateUser, GetAllUsers, GetUserByID, UpdateUser et DeleteUser.
• Chaque fonction se connecte à MongoDB, récupère la collection, effectue l'opération respective et renvoie une réponse JSON.
• Nous traitons les erreurs potentielles et renvoyons les codes d'état HTTP appropriés.

Configuration de l'application principale

Enfin, lions le tout ensemble dans notre fichier main.go :

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/your-username/my-crud-api/handlers"
)

func main() {
    http.HandleFunc("/users", handlers.CreateUser)
    http.HandleFunc("/users", handlers.GetAllUsers)
    http.HandleFunc("/users/", handlers.GetUserByID)
    http.HandleFunc("/users/", handlers.UpdateUser)
    http.HandleFunc("/users/", handlers.DeleteUser)

    fmt.Println("Server running on port 8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Explication :

• Nous enregistrons les gestionnaires d'API avec les points de terminaison HTTP correspondants.
• On démarre le serveur et on écoute sur le port 8080.

Exécuter l'API

1. Variable d'environnement : Définissez la variable d'environnement MONGODB_URI avec votre chaîne de connexion MongoDB.
2. Construire et exécuter : Créez l'application Go à l'aide de go build, puis exécutez-la à l'aide de ./my-crud-api.

Tester l'API

Vous pouvez tester votre API à l'aide d'outils comme Postman ou curl.

• Créer : Envoyez une requête POST à ​​/users avec une charge utile JSON contenant les détails de l'utilisateur.
• Lire : Envoyez une requête GET à /users pour récupérer tous les utilisateurs ou à /users/?id={user_id} pour obtenir un utilisateur spécifique.
• Mise à jour : Envoyez une requête PUT à /users/?id={user_id} avec une charge utile JSON contenant les détails de l'utilisateur mis à jour.
• Supprimer : Envoyez une demande DELETE à /users/?id={user_id} pour supprimer un utilisateur.

Conseils pour réussir

• Gestion des erreurs : Gérez toujours les erreurs potentielles et renvoyez des codes d'état HTTP significatifs.
• Sécurité : Mettez en œuvre des mécanismes d'authentification et d'autorisation appropriés pour votre API.
• Conception de base de données : Concevez votre schéma de base de données de manière réfléchie pour optimiser les performances et l'évolutivité.
• Documentation : Documentez vos points de terminaison d'API, les formats de requête/réponse et les codes d'erreur.

Félicitations ! Vous avez réussi à créer une API CRUD de base à l'aide de Go et MongoDB. Avec cette base, vous pouvez étendre votre API pour gérer des fonctionnalités plus complexes et créer des applications Web impressionnantes. Continuez à apprendre et à explorer les possibilités infinies de Go et MongoDB !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!