Building a Go Application for Google Cloud Vision API

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Accessing the Google Cloud Vision API
  5. Building the Go Application
  6. Testing the Application
  7. Conclusion

Introduction

In this tutorial, we will learn how to build a Go application that interacts with the Google Cloud Vision API. The Google Cloud Vision API enables powerful image analysis and recognition capabilities, allowing developers to integrate image recognition features into their own applications.

By the end of this tutorial, you will have a Go application that can send images to the Google Cloud Vision API for analysis, and retrieve and display the obtained results.

Prerequisites

Before starting this tutorial, you should have the following prerequisites:

  • Go programming language installed on your system
  • A Google Cloud Platform (GCP) account with access to the Vision API

Setup

To get started, you need to set up a project in the Google Cloud Platform Console and enable the Vision API. Here are the steps to follow:

  1. Create a new project: Login to the GCP Console (console.cloud.google.com) and create a new project.

  2. Enable the Vision API: In the GCP Console, go to the “API & Services” section and click on “Library” in the sidebar. Search for “Google Cloud Vision API” and enable it for your project.

  3. Set up authentication: To access the Vision API, you need to create a service account key. In the GCP Console, go to “API & Services” -> “Credentials” -> “Create credentials” -> “Service account key”. Select the service account, choose the JSON key type, and click “Create”.

    This will download a JSON key file to your computer. Keep this file in a safe place as we will need it later.

    Now that the initial setup is complete, let’s proceed with building the Go application.

Accessing the Google Cloud Vision API

To interact with the Google Cloud Vision API, we will use the official Go client library provided by Google. This library simplifies the process of authenticating and making API requests.

To install the library, open your command line and run the following command:

go get -u cloud.google.com/go/vision/apiv1

This will download and install the necessary dependencies for the Google Cloud Vision API client.

Building the Go Application

  1. Create a new Go module: In your preferred project directory, create a new directory for your Go application and initialize a new Go module by running the following command:

    ```shell
go mod init <module-name>
```

  2. Add the necessary import statements: Open your Go source file and add the following import statements at the beginning:

    ```go
package main

import (
    "context"
    "fmt"
    "io/ioutil"
    "log"
    vision "cloud.google.com/go/vision/apiv1"
)
```

These import statements bring in the necessary packages for our Go application, including the Google Cloud Vision API client library.

  3. Load the service account key: Read the previously downloaded service account key file into memory by adding the following code:

    ```go
func loadServiceAccountKey(jsonPath string) ([]byte, error) {
    key, err := ioutil.ReadFile(jsonPath)
    if err != nil {
        return nil, fmt.Errorf("failed to read service account key file: %v", err)
    }
    return key, nil
}
```

This function reads the contents of the service account key file into a byte slice.

  4. Create a vision client: Add the following code to create a new Google Cloud Vision API client:

    ```go
func createVisionClient(ctx context.Context, key []byte) (*vision.ImageAnnotatorClient, error) {
    client, err := vision.NewImageAnnotatorClient(ctx, option.WithCredentialsJSON(key))
    if err != nil {
        return nil, fmt.Errorf("failed to create vision client: %v", err)
    }
    return client, nil
}
```

This function creates a new Vision API client using the provided service account key.

  5. Annotate an image: Add the following code to send an image to the Vision API for annotation:

    ```go
func annotateImage(ctx context.Context, client *vision.ImageAnnotatorClient, imagePath string) error {
    image, err := vision.NewImageFromURI(imagePath)
    if err != nil {
        return fmt.Errorf("failed to create image from URI: %v", err)
    }

    annotations, err := client.DetectLabels(ctx, image, nil, 10)
    if err != nil {
        return fmt.Errorf("failed to detect labels: %v", err)
    }

    for _, label := range annotations {
        fmt.Printf("Label: %s, Score: %.2f\n", label.GetDescription(), label.GetScore())
    }

    return nil
}
```

This function takes a path to an image file as input, creates an image object using the Vision API client, and sends it to the `DetectLabels` method to obtain label annotations. It then prints the labels and their scores to the console.

Testing the Application

Now that our Go application is ready, we can test it by providing an image file as input. Here’s how you can test the application:

  1. Place an image file: Copy an image file to your project directory.

  2. Update the main function: Add the following code to the main function of your Go application:

    ```go
func main() {
    ctx := context.Background()

    key, err := loadServiceAccountKey("<path-to-service-account-key>")
    if err != nil {
        log.Fatalf("failed to load service account key: %v", err)
    }

    client, err := createVisionClient(ctx, key)
    if err != nil {
        log.Fatalf("failed to create vision client: %v", err)
    }

    imagePath := "<path-to-image>"
    err = annotateImage(ctx, client, imagePath)
    if err != nil {
        log.Fatalf("failed to annotate image: %v", err)
    }
}
```

Replace `<path-to-service-account-key>` with the actual path to your service account key file, and `<path-to-image>` with the path to your image file.

  3. Run the application: Open your command line and navigate to your project directory. Run the following command:

    ```shell
go run .
```

The application should now send the image to the Vision API for annotation and display the labels and scores in the console.

Conclusion

Congratulations! You have successfully built a Go application that interacts with the Google Cloud Vision API. You have learned how to set up the necessary credentials, create a Vision API client, and send images for annotation.

You can further enhance this application by exploring other features of the Google Cloud Vision API, such as detecting landmarks, text, or faces in images. Additionally, you can integrate this application with other services or frameworks to create more advanced image recognition solutions.

Happy coding!

Published:

Related Articles