Securing APIs in Golang using the Gin web framework is both important and surprisingly straightforward if you know your way around JSON Web Token (JWT) authentication. JWTs give you a stateless, efficient way to keep your endpoints safe and your users sound. This guide will walk through making that happen step by step, but in easy-peasy terms so even a beginner can follow along. So, let’s dive right into it!
First things first, you need to get your Golang project ready. This means creating a new directory, initializing a Go module, and grabbing all the necessary packages. If these terms are gibberish to you, don’t worry—just follow along with these simple commands:
mkdir my-gin-app
cd my-gin-app
go mod init my-gin-app
go get -u github.com/gin-gonic/gin
go get -u golang.org/x/crypto/bcrypt
go get -u github.com/golang-jwt/jwt/v4
go get -u github.com/joho/godotenv
Next up, let’s talk middleware. For JWT authentication in Gin, you can use a middleware package that practically does half the job for you. One popular choice is github.com/appleboy/gin-jwt. Install it by running:
go get github.com/appleboy/gin-jwt
Now, let’s set up a basic Gin server just to get things warmed up. We’re talking about setting up a simple “Hello World” endpoint. Here’s the code for that:
package main
import (
"github.com/gin-gonic/gin"
"net/http"
)
func main() {
router := gin.New()
router.Use(gin.Logger(), gin.Recovery())
router.GET("/hello", func(c *gin.Context) {
c.JSON(200, gin.H{"message": "Hello World"})
})
router.Run(":8000")
}
Okay, let’s turn it up a notch and bring JWT middleware into the mix. This will help handle token generation, validation, and refresh—basically everything you need to keep things secure:
package main
import (
"github.com/appleboy/gin-jwt"
"github.com/gin-gonic/gin"
"net/http"
"time"
)
func main() {
router := gin.New()
router.Use(gin.Logger(), gin.Recovery())
authMiddleware, err := jwt.New(&jwt.GinJWTMiddleware{
Realm: "test zone",
Key: []byte("secret key"),
Timeout: time.Hour,
MaxRefresh: time.Hour,
Authenticator: func(userId string, password string, c *gin.Context) (string, bool) {
if userId == "admin" && password == "admin" {
return userId, true
}
return "", false
},
Authorizator: func(userId string, c *gin.Context) bool {
if userId == "admin" {
return true
}
return false
},
Unauthorized: func(c *gin.Context, code int, message string) {
c.JSON(code, gin.H{"code": code, "message": message})
},
TokenLookup: "header:Authorization",
})
if err != nil {
panic(err)
}
auth := router.Group("/auth")
{
auth.POST("/login", authMiddleware.LoginHandler)
auth.GET("/refresh", authMiddleware.RefreshHandler)
}
protected := router.Group("/protected")
protected.Use(authMiddleware.MiddlewareFunc())
{
protected.GET("/hello", func(c *gin.Context) {
claims := jwt.ExtractClaims(c)
c.JSON(200, gin.H{"userID": claims["id"], "text": "Hello World"})
})
}
router.Run(":8000")
}
Next on our to-do list is integrating a database, because a robust application needs a solid way to handle user data. We’ll use GORM with a PostgreSQL database. Trust me, it sounds more complicated than it actually is:
package main
import (
"gorm.io/driver/postgres"
"gorm.io/gorm"
)
type User struct {
ID uint `json:"id" gorm:"primaryKey"`
Username string `json:"username"`
Password string `json:"password"`
}
func main() {
dsn := "host=localhost user=postgres password=postgres dbname=postgres port=5432 sslmode=disable"
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
if err != nil {
panic(err)
}
db.AutoMigrate(&User{})
}
Now let’s get into the nitty-gritty of authentication—signing up and logging in users. These endpoints will let users create accounts and then log in to receive their JWTs. Here’s how you can set it all up:
package main
import (
"github.com/gin-gonic/gin"
"golang.org/x/crypto/bcrypt"
"net/http"
)
func signupHandler(c *gin.Context) {
var user User
if err := c.BindJSON(&user); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(user.Password), bcrypt.DefaultCost)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
user.Password = string(hashedPassword)
db.Create(&user)
c.JSON(http.StatusOK, gin.H{"message": "User created successfully"})
}
func loginHandler(c *gin.Context) {
var user User
if err := c.BindJSON(&user); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
var existingUser User
db.Where("username = ?", user.Username).First(&existingUser)
if err := bcrypt.CompareHashAndPassword([]byte(existingUser.Password), []byte(user.Password)); err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid credentials"})
return
}
token, _, err := authMiddleware.TokenGenerator(existingUser.ID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{"token": token})
}
func main() {
// Other routes...
router.POST("/signup", signupHandler)
router.POST("/login", loginHandler)
// Other routes...
}
One of the best practices in coding is keeping sensitive information, like database credentials and secret keys, out of your source code. You can achieve this by using environment variables. The package github.com/joho/godotenv helps you load these variables from a .env file:
package main
import (
"github.com/joho/godotenv"
)
func main() {
err := godotenv.Load()
if err != nil {
panic(err)
}
// Rest of your code...
}
Setting up JWT in your Golang Gin app locks down your APIs effectively. This guide covers the whole shebang—from initializing your project, grabbing essential packages, setting up a basic server, and weaving JWT authentication into it. It goes through integrating a database to store user credentials, right up to setting up signup and login endpoints.
Remember, while these steps create a solid foundation, real-world applications will need further tweaks, especially around authentication, to make them production-ready. But for now, this setup should give you a great start and make your APIs both secure and scalable. Enjoy coding!
