Creating a Go-Based Microservice for Geo-Targeting

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up the Project
  4. Implementing Geo-Targeting
  5. Testing the Microservice
  6. Conclusion

Introduction

In this tutorial, we will learn how to create a Go-based microservice for geo-targeting. Geo-targeting is the practice of delivering content or advertisements to users based on their geographic location. By the end of this tutorial, you will be able to implement a microservice that can determine the location of a given IP address and provide relevant information.

Prerequisites

To follow this tutorial, you should have a basic understanding of the Go programming language and be familiar with concepts like HTTP requests and JSON. You will also need the following software installed on your machine:

  • Go (version 1.15 or later)
  • Text editor or Go IDE of your choice

Setting Up the Project

Before we start implementing the microservice, let’s set up the project structure. Open your terminal and follow these steps:

  1. Create a new directory for your project: mkdir geo-targeting-microservice
  2. Navigate to the project directory: cd geo-targeting-microservice

  3. Initialize a new Go module: go mod init github.com/your-username/geo-targeting-microservice

  4. Create a new main Go file: touch main.go

    Your project structure should now look like this:

     geo-targeting-microservice/
 ├── go.mod
 └── main.go

Implementing Geo-Targeting

Importing Dependencies

In main.go, we need to import the necessary dependencies. We will use the net/http package to handle HTTP requests, the encoding/json package to parse JSON, and the github.com/oschwald/geoip2-golang package to perform IP geolocation lookups using a MaxMind GeoIP2 database.

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/oschwald/geoip2-golang"
)

Handling HTTP Requests

Next, we will define a handler function that will be responsible for handling incoming HTTP requests. This function will extract the IP address from the request, perform the geolocation lookup, and return the result as JSON.

func geoTargetingHandler(w http.ResponseWriter, r *http.Request) {
	ip := r.FormValue("ip")

	// Load the MaxMind GeoIP2 database
	db, err := geoip2.Open("path/to/geoip2/database.mmdb")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// Perform the geolocation lookup
	record, err := db.City(net.ParseIP(ip))
	if err != nil {
		log.Fatal(err)
	}

	// Convert the geolocation result to JSON
	response := map[string]string{
		"ip":           ip,
		"country_code": record.Country.IsoCode,
		"city":         record.City.Names["en"],
	}

	jsonResponse, err := json.Marshal(response)
	if err != nil {
		log.Fatal(err)
	}

	// Set the Content-Type header to application/json
	w.Header().Set("Content-Type", "application/json")

	// Write the JSON response
	_, err = w.Write(jsonResponse)
	if err != nil {
		log.Fatal(err)
	}
}

Registering the Handler

To make our handler function accessible via an HTTP endpoint, we need to register it with the http package’s default ServeMux.

func main() {
	http.HandleFunc("/geo", geoTargetingHandler)

	log.Fatal(http.ListenAndServe(":8080", nil))
}

Testing the Microservice

To test the microservice, follow these steps:

  1. Start the microservice: go run main.go

  2. Open your web browser and navigate to http://localhost:8080/geo?ip=8.8.8.8 (replace 8.8.8.8 with any IP address you want to geolocate)

    You should see a JSON response containing the geolocation information for the provided IP address.

Conclusion

In this tutorial, we have learned how to create a Go-based microservice for geo-targeting. We covered the basic setup, importing dependencies, handling HTTP requests, and testing the microservice. Now you can extend this microservice by adding more functionality or integrating it into your existing projects.

Remember to handle errors properly and ensure the security and reliability of your microservice in a production environment.

Published:

Related Articles