Developing a Go-Based Microservice for Coupon Management

Introduction
Prerequisites
Setting Up the Project
Creating the Coupon Service
Implementing Coupon CRUD Operations
Testing the Coupon Service
Conclusion

Introduction

In this tutorial, we will learn how to develop a Go-based microservice for coupon management. We will create a coupon service that allows users to perform CRUD (Create, Read, Update, Delete) operations on coupons. By the end of this tutorial, you will have a working microservice that can handle coupon management tasks.

Prerequisites

To follow this tutorial, you should have a basic understanding of Go programming language and familiarity with RESTful APIs. You will also need the following software installed on your system:

Go (version 1.16 or above)
Any code editor of your choice (e.g., Visual Studio Code)

Setting Up the Project

To begin, let’s set up the project structure and dependencies.

Create a new directory for your project: mkdir coupon-service
Navigate into the project directory: cd coupon-service
Initialize a Go module: go mod init github.com/yourusername/coupon-service
Create a main package file: touch main.go

Your project directory structure should now look like this:
```
 coupon-service/
   ├── main.go
   └── go.mod
```

Creating the Coupon Service

Now, let’s start building the coupon service.

Open the main.go file in your code editor.

Add the necessary import statements to the top of the file:

 package main
    
 import (
 	"fmt"
 	"log"
 	"net/http"
 )
    
 func main() {
 	fmt.Println("Coupon Service is running...")
 }

In the above code, we import the required packages for our microservice.

Add an HTTP handler function to handle the root route:

 func handleRoot(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprint(w, "Welcome to the Coupon Service!")
 }

Register the HTTP handler function in the main function:
```
 func main() {
 	http.HandleFunc("/", handleRoot)
 	log.Fatal(http.ListenAndServe(":8080", nil))
 }
```
This code sets up a basic HTTP server that listens on port 8080 and handles the root route by calling the handleRoot function.
Save the changes and run the microservice: go run main.go

You should see the message “Coupon Service is running…” in the console. Open your web browser and navigate to http://localhost:8080. You should see the message “Welcome to the Coupon Service!” displayed in the browser.

Implementing Coupon CRUD Operations

Next, let’s implement the coupon CRUD operations.

Create a new file called handlers.go in the project directory.
Add the necessary import statements to the top of the file:
```
 package main
    
 import "net/http"
```

Create a new HTTP handler function for creating a coupon:

 func handleCreateCoupon(w http.ResponseWriter, r *http.Request) {
 	// Implement coupon creation logic here
 }

Repeat the same steps to create handler functions for reading, updating, and deleting a coupon:

 func handleReadCoupon(w http.ResponseWriter, r *http.Request) {
 	// Implement coupon reading logic here
 }
    
 func handleUpdateCoupon(w http.ResponseWriter, r *http.Request) {
 	// Implement coupon updating logic here
 }
    
 func handleDeleteCoupon(w http.ResponseWriter, r *http.Request) {
 	// Implement coupon deletion logic here
 }

 func main() {
 	http.HandleFunc("/", handleRoot)
 	http.HandleFunc("/coupon", handleCreateCoupon)
 	http.HandleFunc("/coupon/{id}", handleReadCoupon)
 	http.HandleFunc("/coupon/{id}", handleUpdateCoupon)
 	http.HandleFunc("/coupon/{id}", handleDeleteCoupon)
 	log.Fatal(http.ListenAndServe(":8080", nil))
 }

Save the changes and run the microservice: go run main.go

Now you have the basic skeleton of the coupon service with CRUD operations. You can test the endpoints using tools like cURL or Postman.

Testing the Coupon Service

To test the coupon service, we will use the cURL command-line tool.

Open a new terminal window.
Create a new coupon using cURL:
```
 curl -X POST http://localhost:8080/coupon -d '{
   "code": "SUMMER50",
   "discount": "50%"
 }'
```
You should receive a response indicating that the coupon was successfully created.
Read the coupon details using cURL:
```
 curl http://localhost:8080/coupon/{id}
```
Replace {id} with the actual coupon ID. You should receive the coupon details in the response.
Update the coupon using cURL:
```
 curl -X PUT http://localhost:8080/coupon/{id} -d '{
   "discount": "75%"
 }'
```
Replace {id} with the actual coupon ID. You should receive a response indicating that the coupon was updated successfully.
Delete the coupon using cURL:
```
 curl -X DELETE http://localhost:8080/coupon/{id}
```
Replace {id} with the actual coupon ID. You should receive a response indicating that the coupon was deleted successfully.

Conclusion

Congratulations! You have successfully developed a Go-based microservice for coupon management. In this tutorial, we covered the basics of setting up a Go project, creating an HTTP server, implementing coupon CRUD operations, and testing the service using cURL. You can now extend this microservice by adding more features or integrating it with other services. Happy coding!

Published: 28 September 2020