Writing a Go-Based Microservice for Sentiment Analysis

Introduction
Prerequisites
Setting Up the Project
Creating the Sentiment Analyzer
Building the REST API
Testing the Microservice
Conclusion

Introduction

In this tutorial, you will learn how to build a Go-based microservice for sentiment analysis. Sentiment analysis involves determining the emotional tone behind a series of words or text. We will create a microservice that accepts a text input and returns the sentiment analysis result using a REST API.

By the end of this tutorial, you will have a fully functional Go microservice that can analyze the sentiment of any given text. We will cover topics such as setting up the project, creating the sentiment analyzer, building the REST API, and testing the microservice.

Prerequisites

Before starting this tutorial, you should have basic knowledge of the Go programming language. Familiarity with REST APIs and web development concepts will also be helpful. Ensure that you have Go installed on your machine.

Setting Up the Project

Create a new project directory for our microservice:

```bash
mkdir sentiment-analysis-microservice
cd sentiment-analysis-microservice
```

Initialize a Go module in the project directory:

```bash
go mod init github.com/your-username/sentiment-analysis-microservice
```

Install necessary Go packages:

```bash
go get github.com/gin-gonic/gin
go get github.com/cdipaolo/sentiment
```

Creating the Sentiment Analyzer

In this section, we will create the sentiment analyzer that will perform the actual sentiment analysis on the text input.

Create a new file called sentiment.go in the project directory:
```
```bash
touch sentiment.go
```
```
Open the sentiment.go file in your preferred text editor.

Import the necessary packages:

```go
package main

import (
    "github.com/cdipaolo/sentiment"
    "github.com/cdipaolo/sentiment/analysis"
)
```

Define a function AnalyzeSentiment that takes a text string as input and returns a sentiment analysis result:

```go
func AnalyzeSentiment(text string) analysis.SentimentResult {
    model, err := sentiment.Restore()
    if err != nil {
        panic(err)
    }

    analysis := model.SentimentAnalysis(text, sentiment.English)
    return analysis
}
```

Save and close the sentiment.go file.

Building the REST API

Now that our sentiment analyzer is ready, we will create a REST API using the popular Gin framework to expose the sentiment analysis functionality.

Create a new file called main.go in the project directory:
```
```bash
touch main.go
```
```
Open the main.go file in your preferred text editor.

Import the necessary packages:

```go
package main

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

Define the main function:

```go
func main() {
    r := gin.Default()

    r.POST("/sentiment", func(c *gin.Context) {
        var input struct {
            Text string `json:"text" binding:"required"`
        }
        if err := c.ShouldBindJSON(&input); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        // Perform sentiment analysis on the input text
        analysis := AnalyzeSentiment(input.Text)

        // Return the sentiment analysis result as JSON
        c.JSON(http.StatusOK, gin.H{
            "result": analysis.Result(),
        })
    })

    r.Run() // Run the server
}
```

This code sets up a POST endpoint `/sentiment` that expects a JSON payload with a `text` field. It then calls the `AnalyzeSentiment` function we created earlier and returns the sentiment analysis result.

Save and close the main.go file.

Testing the Microservice

Start the microservice by running the following command in the project directory:
```
```bash
go run main.go
```
```

Use a tool like cURL or Postman to send a POST request to http://localhost:8080/sentiment with the following JSON payload:

```json
{
    "text": "I love this tutorial!"
}
```

You should receive a response similar to the following:

```json
{
    "result": "Positive"
}
```

Experiment with different text inputs and observe the sentiment analysis results.

Conclusion

Congratulations! You have successfully built a Go-based microservice for sentiment analysis using a REST API. You learned how to set up the project, create the sentiment analyzer, build the REST API, and test the microservice.

This tutorial covered topics from networking and web programming, as well as best practices and design patterns. You can now extend this microservice by adding more endpoints or integrating it with other services. Go ahead and explore the possibilities with Go!

Published: 6 September 2021