Creating a Go-Based Microservice for User Profile Management

Introduction
Prerequisites
Setting Up the Project
Defining User Profile Data Structure
Implementing CRUD Operations
Testing the Microservice
Conclusion

Introduction

In this tutorial, we will learn how to create a Go-based microservice for user profile management. We will design and develop the microservice to perform CRUD (Create, Read, Update, Delete) operations on user profiles. By the end of this tutorial, you will have a working microservice that can handle user profile management.

Prerequisites

Before starting this tutorial, you should have a basic understanding of the Go programming language and its syntax. Familiarity with RESTful APIs and web development concepts will also be helpful. Additionally, make sure you have Go installed on your system. You can download and install Go from the official website: https://golang.org/dl/

Setting Up the Project

First, create a new directory to hold your project files:

 mkdir user-profile-microservice
 cd user-profile-microservice

Initialize a new Go module by running the following command:
```
 go mod init github.com/your-username/user-profile-microservice
```
Replace “your-username” with your actual GitHub username or any other relevant identifier.
Next, create a new file named main.go in the project directory:
```
 touch main.go
```
Open main.go in a text editor and import the necessary packages:
```
 package main
    
 import (
 	"encoding/json"
 	"log"
 	"net/http"
 	"github.com/gorilla/mux"
 )
```
We import the encoding/json package for JSON encoding and decoding, the log package for logging, the net/http package for handling HTTP requests and responses, and the github.com/gorilla/mux package for routing.

Defining User Profile Data Structure

In main.go, define the data structure for the user profile:

 type UserProfile struct {
 	ID        string `json:"id"`
 	FirstName string `json:"first_name"`
 	LastName  string `json:"last_name"`
 	Email     string `json:"email"`
 }

The UserProfile struct represents a user profile and includes fields for the ID, first name, last name, and email address.

Next, create an in-memory database to store user profiles:
```
 var profiles []UserProfile
```
We declare a slice of UserProfile structs to hold the user profiles.

Implementing CRUD Operations

Now, let’s implement the endpoints for creating, reading, updating, and deleting user profiles. Add the following code to main.go:

 func CreateProfile(w http.ResponseWriter, r *http.Request) {
 	var profile UserProfile
 	json.NewDecoder(r.Body).Decode(&profile)
 	profiles = append(profiles, profile)
 	json.NewEncoder(w).Encode(profile)
 }
    
 func GetProfile(w http.ResponseWriter, r *http.Request) {
 	params := mux.Vars(r)
 	for _, profile := range profiles {
 		if profile.ID == params["id"] {
 			json.NewEncoder(w).Encode(profile)
 			return
 		}
 	}
 	json.NewEncoder(w).Encode(nil)
 }
    
 func UpdateProfile(w http.ResponseWriter, r *http.Request) {
 	params := mux.Vars(r)
 	var updatedProfile UserProfile
 	json.NewDecoder(r.Body).Decode(&updatedProfile)
 	for i := range profiles {
 		if profiles[i].ID == params["id"] {
 			profiles[i] = updatedProfile
 			json.NewEncoder(w).Encode(profiles[i])
 			return
 		}
 	}
 	json.NewEncoder(w).Encode(nil)
 }
    
 func DeleteProfile(w http.ResponseWriter, r *http.Request) {
 	params := mux.Vars(r)
 	for i := range profiles {
 		if profiles[i].ID == params["id"] {
 			profiles = append(profiles[:i], profiles[i+1:]...)
 			break
 		}
 	}
 	json.NewEncoder(w).Encode(nil)
 }
    
 func main() {
 	router := mux.NewRouter()
    
 	router.HandleFunc("/profiles", CreateProfile).Methods("POST")
 	router.HandleFunc("/profiles/{id}", GetProfile).Methods("GET")
 	router.HandleFunc("/profiles/{id}", UpdateProfile).Methods("PUT")
 	router.HandleFunc("/profiles/{id}", DeleteProfile).Methods("DELETE")
    
 	log.Fatal(http.ListenAndServe(":8000", router))
 }

In the above code, we define the functions for each CRUD operation: CreateProfile, GetProfile, UpdateProfile, and DeleteProfile. These functions handle the corresponding HTTP requests and manipulate the profiles slice according to the requested operation. We use the json package to encode and decode JSON data.

The main function sets up the router using the gorilla/mux package and starts the HTTP server on port 8000.

Testing the Microservice

To test the microservice, open a terminal and run the following command:
```
 go run main.go
```
This will start the microservice and make it accessible at http://localhost:8000.
Use a tool like cURL or Postman to send HTTP requests to the microservice’s endpoints:
- To create a profile, send a POST request to http://localhost:8000/profiles with a JSON payload containing the profile data.
- To get a profile, send a GET request to http://localhost:8000/profiles/{id}, where {id} is the ID of the profile you want to retrieve.
- To update a profile, send a PUT request to http://localhost:8000/profiles/{id} with a JSON payload containing the updated profile data.
- To delete a profile, send a DELETE request to http://localhost:8000/profiles/{id}, where {id} is the ID of the profile you want to delete.

Conclusion

In this tutorial, we created a Go-based microservice for user profile management. We learned how to define the user profile data structure and implemented CRUD operations for creating, reading, updating, and deleting user profiles. By following this tutorial, you should now have a basic understanding of how to build a microservice in Go and handle user profile management.

Published: 8 September 2019