Attempting to Learn Go - Consuming a REST API

#go #continuingeducation #atlg

I've been thinking a lot about REST APIs recently. Working for a SaaS company seems to all but guarantees that you will come in contact with one (or dozens) so I suppose that makes sense. Since I've been working on some basic code and practicing my Go, I thought that it might be nice to jot down some notes and maybe some code to continue my Learning Go "series".

Getting started with basic API consumption is pretty easy thanks to Go's built-in net/http package. Practically everything needed to query a remote API is available in the Go standard library.

We'll start with our standard Go opening... and sticking with main for our package name since this is just an example. We'll import fmt, io/ioutil, net/http - strictly speaking we don't need fmt but since we're not really doing anything with the API response, other than printing it out it's included.

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

Next let's open our main function and declare our API URL, for this exercise we're just going to query httpbin.org. Passing our URL and the "GET" method to http.NewRequest will give us back a proper http.Request object (if no error occurs) that we can use in the next step.

func main() {
    APIURL := "https://httpbin.org/get"
    req, err := http.NewRequest(http.MethodGet, APIURL, nil)
    if err != nil {
        panic(err)
    }

Using http we create a default client, this will handle the actual request to the remote server. Finally, we'll call Do() and actually make the request, receiving back a response or an error. It's Go so we'll check for errors and move on if we don't have one.

    client := http.DefaultClient
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }

Assuming we received a valid response we're going to begin to process it. First, we'll defer closing the response body, this way we can read out the data and Go will simply take care of closing it once the surrounding function returns. But first, we'll use ioutil.ReadAll to read in the body and return an array of bytes - as long as there is no error that is.

    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

Finally, lets convert our array of bytes to a string and print it to standard out.

    fmt.Printf("%v", string(body))

And presto! That's all there is to get data from a remote REST endpoint in Go.

{
  "args": {},
  "headers": {
    "Accept-Encoding": "gzip",
    "Connection": "close",
    "Host": "httpbin.org",
    "User-Agent": "Go-http-client/1.1"
  },
  "origin": "68.211.xx.xx",
  "url": "https://httpbin.org/get"
}

Next time I think I'll expand this into a module that we can use for future REST work. From there we'll probably write something that actually makes use of the consumed API.

You can find the code for this and most of the other Attempting to Learn Go posts in the repo on GitHub.

shindakun / atlg

Source repo for the "Attempting to Learn Go" posts I've been putting up over on dev.to

Attempting to Learn Go

Here you can find the code I've been writing for my Attempting to Learn Go posts that I've been writing and posting over on Dev.to.

Post Index

Post	Code
Building a Downloader Part 01	-
Building a Downloader Part 02	-
Building a Downloader Part 03	-
Building a Downloader Part 04	-
Building a Downloader Part 05	-
Consuming a REST API	src
Continuing REST Adventures	src
Now Sending REST Requests	src
REST API and A Bit On Templates	src
Sending Email Via API Again	src
Let's Get Modular!	src
Let's Get Modular - Again!	src
Building DevLog Part 01	src
Building DevLog Part 02	src
Building DevLog Part 03	src
Building DevLog Part 04	src
Building DevLog Part 05	src
Listing Files By Extension 01	src
Listing Files By Extension 02	src
Dev.to API 01	src
Dev.to API 02	see above code

View on GitHub

Enjoy this post?
How about buying me a coffee?

Oldest comments (5)

Adrian B.G. • Nov 22 '18 • Edited

Nice!

Just to be picky, when I see Go code I can't help it sorry, ALL_UPPER is not idiomatic, even constants follow the normal naming conventions camel/pascal case (APIURL).

And a warning for the new gopher readers, be careful in production:

the default net/http instances does not timeout, including the default http.Defaultclient
you usually do not use ioutil.ReadAll, especially when you read the Requests (as a web server), if someone post you a 3GB payload it will try to read it all. To protect our code we can use Limiters like golang.org/pkg/net/http/#MaxBytesR...

Having a public web server inside our code is one of the biggest challenge, especially for the devs coming from an interpreted languge, at least for me. We do not have all the protection Nginx or Apache gave us, we have to be more careful. Using Throttlers, Limiters, Timeouts and such is a must!

Also when speaking about REST, I recommend using goswagger.io/, it handles everything for us, generating Server and Client code based on a Swagger config.

Steve Layton • Nov 22 '18

Thanks for the comments! I usually just defer to golint and try not think about it too much, the machine (or the authors of golint in this case) prefers all uppercase. main.go:12:6: var ApiURL should be APIURL. Yeah for a production webserver we'd definitly want to set up a timeout, typically I'd tend to deply behind Nginx anyway to take advantage of its caching. This example will probably change a bit over the next couple posts but it will likely not turn into a webserver (at least not yet) so I think ioutil.ReadAll and the http.DefaultClient should be fine for now. Though now you've given me another post I could mix in. ;)

Samuel Fuller • Aug 19 '19

I had been trying to have my go program communicate with an API for like 2 days now.. Once I came across this post I was able to get everything working as intended. Very basic, straightforward, and life saving. Thank you so much.