From Setup to CRUD Operations with Gin & PostgreSQL
Golang is a fantastic programming language! If you're just starting out, the official documentation is a great resource. But when it comes to practical application, things can get tricky.
Many developers have asked me how to build a RESTful API using Go, so I decided to create a minimal working REST API with step-by-step guidance. Let's dive in! 🔥
🛠 Step-by-Step Guide to Building a REST API in Go
We'll be using:
✅ Gin (Fast & lightweight web framework)
✅ GORM (ORM for PostgreSQL)
✅ Docker (To run PostgreSQL in a container)
Step 1: Setting Up the Project & Installing Dependencies
First, create a new Go project:
mkdir go-rest-api && cd booking-app
go mod init booking-app
Next, install Gin:
go get -u github.com/gin-gonic/gin
Create the initial route
create file routes/booking.go
package routes
import (
"net/http"
"github.com/gin-gonic/gin"
)
func GetBookings(c *gin.Context) {
var bookings []string = []string{"abc"}
c.JSON(http.StatusOK, bookings)
}
func SetupRoutes(router *gin.Engine) {
router.GET("v1/bookings", GetBookings)
}
To use above route in main.go, create a file main.go
package main
import (
"booking-app/routes"
"fmt"
"github.com/gin-gonic/gin"
)
func main() {
// Setup Gin Router
router := gin.Default()
routes.SetupRoutes(router)
// Start the server
port := ":8080"
fmt.Println("Server is running on port", port)
router.Run(port)
}
run
go run main.go
visit http://localhost:8080/v1/bookings you should get a response with ["abc"]
Step 2: Setting Up PostgreSQL Using Docker:
Instead of installing PostgreSQL manually, let's use Docker.
To make sure that the starting docker container lives with the application itself, let create a docker-compose
docker-compose.yml
version: '3.8'
services:
postgres:
image: postgres:latest
container_name: postgres_container
restart: always
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: yourpassword
POSTGRES_DB: booking_db
ports:
- "5432:5432"
volumes:
- postgres_data:/var/lib/postgresql/data
volumes:
postgres_data:
run
docker-compose up -d
make sure that the docker is running in background
adding DB connectivity to the app
create the file config/database.go
package config
import (
"fmt"
"log"
"gorm.io/driver/postgres"
"gorm.io/gorm"
)
var DB *gorm.DB
func ConnnetDatabse() {
dsn := "host=localhost user=postgres password=yourpassword dbname=booking_db port=5432 sslmode=disable"
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
if err != nil {
// log.Fatal will log the message to terminal and exit the program
log.Fatal("Failed to connect to the database:", err)
}
DB = db
fmt.Println("Connected to PostgreSQL!")
}
add following line at the top of the function main in main.go to initialise the database connection.
config.ConnnetDatabse()
The step 2 github link
Step 3: Adding a Data Model & First Route (Create a Resource)
Let's define a model for our API.
First, install GORM and the PostgreSQL driver:
go get -u gorm.io/gorm
go get -u gorm.io/driver/postgres
create the modal
package models
import "gorm.io/gorm"
type User struct {
gorm.Model
Name string `json:"name" binding:"required" gorm:"not null"`
Email string `json:"email" binding:"required,email" gorm:"not null"`
Date string `json:"date"`
}
gorm.Modal adds few default fields to the struct as ID, CreatedAt, UpdatedAt, DeletedAt and managed by it self.
bindind make sure that the fileds are validate when the json is binded to the modal.
lets create a controller to for bookings
controller/bookings.go
package controllers
import (
"booking-app/config"
"booking-app/models"
"net/http"
"github.com/gin-gonic/gin"
)
func GetBookings(c *gin.Context) {
var bookings []models.Booking
config.DB.Find(&bookings)
c.JSON(http.StatusOK, bookings)
}
func CreateBooking(c *gin.Context) {
var booking models.Booking
if err := c.ShouldBindJSON(&booking); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
config.DB.Create(&booking)
c.JSON(http.StatusCreated, booking)
}
We have created a handler for creating bookings and moved the logic to get bookings from routes file as well.
now update the routes/booking.go as well.
package routes
import (
"booking-app/controllers"
"github.com/gin-gonic/gin"
)
func SetupRoutes(router *gin.Engine) {
router.GET("v1/bookings", controllers.GetBookings)
router.POST("v1/bookings", controllers.CreateBooking)
}
now let's test the endpoint
curl -X POST http://localhost:8080/v1/bookings -H "Content-Type: application/json" -d '{"name":"John Doe", "email":"john@example.com"}'
code for step 3
Step 4: Get a booking by ID
Lets update the controller to get a booking
func GetBookingsById(c *gin.Context) {
id := c.Param("id")
var booking models.Booking
err := config.DB.First(&booking, id).Error
if err != nil {
c.JSON(http.StatusNotFound, nil)
return
}
c.JSON(http.StatusOK, booking)
}
lets add the route to routes/booking.go
router.GET("v1/bookings/:id", controllers.GetBookingsById)
By re-running the application you should be able to fetch booking by id
code for step 04
Step 5: Update & Delete Operations
now you guessed right. know the drill. update the controller, ad it to route.
controllers/booking.go
type UpdateBookingRequest struct {
Name string `json:"name"`
Email string `json:"email"`
Date string `json:"date"`
}
func UpdateBooking(c *gin.Context) {
var id = c.Param("id")
var booking models.Booking
var updateRequest UpdateBookingRequest
err := config.DB.First(&booking, id)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Booking not found"})
}
if err := c.ShouldBindJSON(&updateRequest); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
if err := config.DB.Model(&booking).Updates(updateRequest).Error; err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "Internal server error"})
return
}
c.JSON(http.StatusOK, booking)
}
func DeleteBooking(c *gin.Context) {
var id = c.Param("id")
var booking models.Booking
if err := config.DB.First(&booking, id).Error; err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Booking not found"})
return
}
if err := config.DB.Delete(&booking).Error; err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "Internal server error"})
return
}
c.JSON(http.StatusOK, booking)
}
wait, there is a new struct for updates, Yes. that's because we have already added validations for bookings modal as both name and email are required, but for an update we might only need to update one of it not both. other than that this enables adding custom validations only for update request if needed.
routes/booking.go
router.PUT("v1/bookings/:id", controllers.UpdateBooking)
router.DELETE("v1/bookings/:id", controllers.DeleteBooking)
here is the code after adding delete and update operations.
🎉 Conclusion
Congratulations! You’ve built a fully functional RESTful API in Go with: ✅ Gin for routing
✅ PostgreSQL (via Docker) for storage
✅ GORM for database interactions
✅ CRUD operations
Hope you enjoyed this guide! Let me know your thoughts in the comments. 🚀
Top comments (1)
Nice!