In modern web development, RESTful APIs play a crucial role in building robust, flexible, and scalable backend applications. Go (Golang) is a popular programming language for API development due to its high performance and simple syntax. When combined with MongoDB, a powerful NoSQL database, you can create an efficient and scalable API.

This article will guide you on building a RESTful API with Go and MongoDB, from setting up the environment to implementing basic CRUD (Create, Read, Update, Delete) functionalities.

---

1. Setting Up the Environment

Before we start, you need to install the following tools:

• Go: Download and install from golang.org
• MongoDB: Download and install from mongodb.com
• Postman: A tool for API testing (optional but useful)

Next, create a project directory and initialize a Go module:

mkdir go-mongo-api
cd go-mongo-api
go mod init example.com/go-mongo-api

Install the necessary libraries:

go get go.mongodb.org/mongo-driver/mongo
go get github.com/gin-gonic/gin

---

2. Connecting Go with MongoDB

Create a main.go file and add the following code to establish a connection with MongoDB:

package main

import (
    "context"
    "fmt"
    "log"
    "time"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func connectDB() *mongo.Client {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal("Failed to connect to MongoDB")
    }
    
    fmt.Println("Successfully connected to MongoDB")
    return client
}

func main() {
    client := connectDB()
    defer client.Disconnect(context.TODO())
}

Run go run main.go to test the connection.

---

3. Building a CRUD API

a. Setting Up the Router with Gin

Add the gin-gonic/gin library to handle HTTP requests:

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run() 
}

Run go run main.go and test the API at http://localhost:8080/ping.

b. Implementing CRUD API

Below is a simple CRUD API for managing a user list.

Define the User Struct

type User struct {
    ID       primitive.ObjectID `bson:"_id,omitempty" json:"id"`
    Name     string             `json:"name"`
    Email    string             `json:"email"`
}

Create a User

r.POST("/users", func(c *gin.Context) {
    var user User
    if err := c.BindJSON(&user); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    collection := client.Database("testdb").Collection("users")
    result, err := collection.InsertOne(context.TODO(), user)
    if err != nil {
        c.JSON(500, gin.H{"error": "Failed to create user"})
        return
    }
    c.JSON(201, gin.H{"message": "User created successfully", "id": result.InsertedID})
})

Get Users List

r.GET("/users", func(c *gin.Context) {
    var users []User
    collection := client.Database("testdb").Collection("users")
    cursor, err := collection.Find(context.TODO(), bson.M{})
    if err != nil {
        c.JSON(500, gin.H{"error": "Error retrieving users"})
        return
    }
    defer cursor.Close(context.TODO())
    for cursor.Next(context.TODO()) {
        var user User
        cursor.Decode(&user)
        users = append(users, user)
    }
    c.JSON(200, users)
})

Similarly, you can add API endpoints for updating and deleting users.

---

4. Conclusion

We have successfully built a simple RESTful API using Go and MongoDB, covering:

• Setting up the environment
• Connecting Go with MongoDB
• Implementing CRUD functionalities

You can further enhance this API by adding authentication, pagination, or deploying it to the cloud.

If you found this guide helpful, feel free to share it!