Creating a Go-Based Microservice for Inventory Management

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Project Setup
  4. Creating the Microservice
  5. Endpoint for Retrieving Inventory
  6. Endpoint for Updating Inventory
  7. Conclusion

Introduction

In this tutorial, we will learn how to create a Go-based microservice for inventory management. We will build a basic microservice that exposes two endpoints - one for retrieving the inventory and another for updating the inventory. By the end of this tutorial, you will be able to create a scalable and maintainable microservice to manage inventory efficiently.

Prerequisites

Before starting this tutorial, you should have a basic understanding of the Go programming language. Familiarity with concepts like HTTP endpoints and JSON handling would be beneficial. Additionally, you will need the following software installed on your machine:

  • Go (version 1.14 or higher)
  • Text editor or integrated development environment (IDE)

Project Setup

  1. Create a new directory for your project: $ mkdir inventory-microservice $ cd inventory-microservice

  2. Initialize a new Go module: $ go mod init github.com/your-username/inventory-microservice

  3. Create a main.go file and open it in your text editor or IDE.

Creating the Microservice

Let’s start by creating a basic HTTP server and handling the requests.

  1. Import the necessary packages: ```go package main

    import (
    "encoding/json"
    "log"
    "net/http"
)
```

  2. Create a struct to represent the inventory item: go type InventoryItem struct { ID int `json:"id"` Name string `json:"name"` Stock int `json:"stock"` }

  3. Create a slice to store the inventory items: go var inventory []InventoryItem

  4. Implement a handler function to retrieve the inventory: go func getInventoryHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(inventory) }

  5. Implement a handler function to update the inventory: ```go func updateInventoryHandler(w http.ResponseWriter, r *http.Request) { // Parse the request body var item InventoryItem err := json.NewDecoder(r.Body).Decode(&item) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return }

        // Update the item in the inventory
    for i, invItem := range inventory {
        if invItem.ID == item.ID {
            inventory[i].Stock = item.Stock
            break
        }
    }

    // Return the updated inventory
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(inventory)
}
```

  6. Set up the main function to start the server: ```go func main() { // Create some initial inventory items inventory = append(inventory, InventoryItem{ID: 1, Name: “Item 1”, Stock: 10}) inventory = append(inventory, InventoryItem{ID: 2, Name: “Item 2”, Stock: 5})

        // Set up the handlers
    http.HandleFunc("/inventory", getInventoryHandler)
    http.HandleFunc("/inventory/update", updateInventoryHandler)

    // Start the server
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

  7. Run the microservice: $ go run main.go

    Now, you have a basic Go microservice running with two endpoints - /inventory for retrieving the inventory and /inventory/update for updating the inventory.

Endpoint for Retrieving Inventory

Let’s test the /inventory endpoint to retrieve the inventory.

  1. Open a web browser or use a tool like cURL or Postman.

  2. Make a GET request to http://localhost:8080/inventory.

  3. You should receive a JSON response with the current inventory items.

Endpoint for Updating Inventory

Now, let’s test the /inventory/update endpoint to update the inventory.

  1. Open a web browser or use a tool like cURL or Postman.

  2. Make a POST request to http://localhost:8080/inventory/update with JSON payload containing the item ID and updated stock.

    Example payload:
```json
{
    "id": 2,
    "stock": 3
}
```

  3. You should receive a JSON response with the updated inventory.

Conclusion

In this tutorial, we have learned how to create a Go-based microservice for inventory management. We built a basic microservice with two endpoints - one for retrieving the inventory and another for updating the inventory. You can further extend this microservice by adding authentication, database integration, and more advanced features based on your requirements. Go’s simplicity and performance make it an ideal choice for developing scalable and efficient microservices.

Published:

Related Articles