Building a Go-Based Microservice for Customer Support Chat

Introduction
Prerequisites
Setup
Creating the Microservice
Implementing the Chat Functionality
Testing the Microservice
Conclusion

Introduction

In this tutorial, we will learn how to build a Go-based microservice for customer support chat. We will leverage Go’s networking capabilities and concurrent programming to create a scalable and efficient solution.

By the end of this tutorial, you will have a functioning microservice that can handle multiple customer support chat sessions concurrently.

Prerequisites

To follow along with this tutorial, you should have the following:

Basic knowledge of Go programming language
Go installed on your machine
Familiarity with RESTful APIs (optional)

Setup

Before we start building the microservice, we need to set up our project. Follow these steps:

Create a new directory for our project:

 mkdir customer-support-chat
 cd customer-support-chat

Initialize a new Go module:
```
 go mod init customer-support-chat
```
Create a main Go file:
```
 touch main.go
```
Now we are ready to start building our microservice.

Creating the Microservice

Open the main.go file in your favorite text editor.

Import the required packages for building our microservice:

 package main
    
 import (
 	"fmt"
 	"log"
 	"net/http"
 )

Create a simple HTTP server to handle incoming requests:

 func main() {
 	http.HandleFunc("/", handleRequest)
 	log.Fatal(http.ListenAndServe(":8080", nil))
 }
    
 func handleRequest(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintf(w, "Welcome to customer support chat!")
 }

In this code, we defined a basic Go HTTP server that listens on port 8080. The / route will be used to handle all incoming requests.

Build and run the microservice:
```
 go build
 ./customer-support-chat
```
Now, if you visit http://localhost:8080 in your browser, you should see the message “Welcome to customer support chat!”.

Implementing the Chat Functionality

Now that we have our basic microservice set up, let’s implement the chat functionality.

Extend the handleRequest function to handle the chat API:

 func handleRequest(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "POST" {
 		// Process chat messages
 	} else {
 		// Return error for unsupported method
 		w.WriteHeader(http.StatusMethodNotAllowed)
 		fmt.Fprintf(w, "Method not allowed")
 	}
 }

Create a ChatMessage struct to represent the chat messages:

 type ChatMessage struct {
 	User    string `json:"user"`
 	Message string `json:"message"`
 }

Implement the logic to process chat messages:

 func handleRequest(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "POST" {
 		var chatMessage ChatMessage
 		err := json.NewDecoder(r.Body).Decode(&chatMessage)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			fmt.Fprintf(w, "Invalid request body")
 			return
 		}
    
 		// Process the chat message
 		fmt.Printf("User: %s, Message: %s\n", chatMessage.User, chatMessage.Message)
 	} else {
 		// Return error for unsupported method
 		w.WriteHeader(http.StatusMethodNotAllowed)
 		fmt.Fprintf(w, "Method not allowed")
 	}
 }

In this code, we decode the JSON request body into a ChatMessage struct and then process the chat message as needed. For demonstration purposes, we simply print the user and message to the console.

Test the chat functionality using cURL or any API testing tool:
```
 curl -X POST -d '{"user":"John","message":"Hello"}' http://localhost:8080
```
You should see the chat message printed in the console.

Testing the Microservice

To ensure the quality and correctness of our microservice, we should write tests.

Create a new test file:
```
 touch main_test.go
```

Write test cases for the chat functionality:

 func TestHandleRequest(t *testing.T) {
 	req := httptest.NewRequest("POST", "/", strings.NewReader(`{"user":"John","message":"Hello"}`))
 	rec := httptest.NewRecorder()
    
 	handleRequest(rec, req)
    
 	res := rec.Result()
 	defer res.Body.Close()
    
 	if res.StatusCode != http.StatusOK {
 		t.Errorf("expected status 200, got %d", res.StatusCode)
 	}
    
 	body, err := ioutil.ReadAll(res.Body)
 	if err != nil {
 		t.Fatal(err)
 	}
    
 	expected := "User: John, Message: Hello\n"
 	if string(body) != expected {
 		t.Errorf("expected response body %q, got %q", expected, body)
 	}
 }

Run the tests:
```
 go test
```
If everything is implemented correctly, you should see the test passed.

Conclusion

In this tutorial, we learned how to build a Go-based microservice for customer support chat. We covered the setup, creation of an HTTP server, implementation of chat functionality, and testing.

To extend this microservice, you can add persistence using a database, implement authentication and authorization, or integrate it with other services via RESTful APIs.

Remember to always follow best practices and design patterns when building production-ready microservices.

Now you have the knowledge and tools to create your own scalable and efficient customer support chat microservice using Go. Good luck with your future projects!

Published: 22 October 2019