DEV Community: cameronldroberts

Gatsby to Hugo

cameronldroberts — Wed, 24 Feb 2021 23:05:23 +0000

I recently decided that I would be moving my personal site from Gatsby to Hugo. I quite enjoyed using Gatsby so I'm not moving due to poor experience but more that I have wanted to give Hugo a try for a while and figured this would be the best project to use it with.

Some cool features of Hugo

It's written in Go! (No Golang programming knowledge required for creating sites with Hugo)
It's lightning fast
The list of available themes is huge and you can also roll your own

Starting the move

My site is pretty small and so it shouldn't be too difficult to move. Both render posts form markdown so there's no need to do any converting.

Setting up the Hugo site

Installation

brew install hugo
hugo version

If Hugo has installed correctly we should see the following output

Hugo Static Site Generator v0.80.0/extended darwin/amd64 BuildDate: unknown

Create a new site

hugo new site hugo-blog

This will create a Hugo site in the current directory.

Adding a theme

There's a huge selection of different themes available which can be found on the themes webpage. I have chosen to use the hugo coder theme thanks to the developers over there for a great theme!

To use the theme we need to download it and add it to the themes directory of our site.

cd hugo-blog
git init 
git submodule add https://github.com/luizdepra/hugo-coder.git themes/hugo-coder

Now that our theme is in place we can add the following to a config.toml file at the root of our project.

baseurl = "https://www.cameronroberts.dev"
title = "Cameron Roberts"
theme = "hugo-coder"
languagecode = "en"
defaultcontentlanguage = "en"
paginate = 20

pygmentsstyle = "bw"
pygmentscodefences = true
pygmentscodefencesguesssyntax = true

[params]
  author = "Cameron Roberts"
  info = "Software Engineer enjoying all things Cloud and IoT"
  description = "Personal site"
  keywords = "blog,developer,personal"
  avatarurl = "images/icon.jpeg"

  footercontent = ""
  hideFooter = true
  hideCredits = true
  hideCopyright = true
  since = 2019

  enableTwemoji = true

  colorScheme = "auto"
  hidecolorschemetoggle = false

#  customCSS = ["css/style.css"]
#   customSCSS = ["scss/custom.scss"]
#   customJS = ["js/custom.js"]
[taxonomies]
  category = "categories"
  series = "series"
  tag = "tags"
  author = "authors"

# Social links
[[params.social]]
  name = "Github"
  icon = "fa fa-github fa-2x"
  weight = 1
  url = "https://github.com/cameronldroberts/"
[[params.social]]
  name = "Twitter"
  icon = "fa fa-twitter fa-2x"
  weight = 2
  url = "https://twitter.com/cameron_1010/"
# [[params.social]]
#     name = "LinkedIn"
#     icon = "fa fa-linkedin"
#     weight = 3
#     url = "https://www.linkedin.com/in/johndoe/"
[[params.social]]
    name = "Medium"
    icon = "fa fa-medium"
    weight = 4
    url = "https://medium.com/@cameronldroberts"
[[params.social]]
    name = "Dev.to"
    icon = "fa fa-dev-to"
    weight = 5
    url = "https://dev.to/cameronldroberts"

# Menu links
[[menu.main]]
  name = "About"
  weight = 1
  url = "about/"

[[menu.main]]
  name = "Blog"
  weight = 2
  url  = "posts/"
[[menu.main]]
  name = "Contact"
  weight = 3
  url  = "contact/"

You will need to change some values such as social links, avatarUrl, title and anything else that points to my site.

Adding content

Now that we have the plumbing sorted we can start adding some content. If you have an old site you want to bring your content from then you can do that quite easily. The markdown files live in content/posts so you could just copy them over

cp ~/dev/oldwebsite/content/* content/posts/

It's worth noting that if you are moving content and have also published this to somewhere like dev.to then your canonical URLs may need changing.

On my Gatsby site the posts could be found under /blog like this

https://cameronroberts.dev/blog/consuming-restapi-golang/

whereas on the Hugo site they will be found under /posts like this

https://cameronroberts.dev/posts/consuming-restapi-golang/

This is worth considering if you do have content posted on other sites. I will be doing a post on how we can cross post to other sites soon so stay tuned.

If you don't have any content to bring over then not to worry as we can quite easily create some

hugo new posts/my-first-post.md

This will generate a file in the content/posts directory that looks like the following

+++ 
draft = true
date = 2021-02-19T23:01:52Z
title = ""
description = ""
slug = ""
authors = []
tags = []
categories = []
externalLink = ""
series = []
+++

I'll leave you fill that in with whatever you want to write about. It can be anything for now, maybe some Lorem Ipsum.

To summarise our progress so far we have

Installed Hugo
Generated a Hugo site
Added a theme to our site
Copied over our old content/added some new content

Now that we have completed these steps we can see our page in action!

Running our site locally

To do this run the following command

hugo serve -D

Hugo will spin up a webserver that builds and serves the site. By default live reload will be enabled which is a great feature as it allows us to see our changes nearly instantly. The -D flag will serve content that is marked as draft which is great for when you are in the process of writing articles but not quite ready to publish.


hugo-blog git:(main) ✗ hugo serve -D                  
Start building sites … 

                   | EN  
-------------------+-----
  Pages            | 48  
  Paginator pages  |  0  
  Non-page files   |  0  
  Static files     |  7  
  Processed images |  0  
  Aliases          | 18  
  Sitemaps         |  1  
  Cleaned          |  0  

Built in 138 ms
Watching for changes in /Users/cameronroberts/dev/hugo-blog/{archetypes,content,data,layouts,static,themes}
Watching for config changes in /Users/cameronroberts/dev/hugo-blog/config.toml
Environment: "development"
Serving pages from memory
Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
Press Ctrl+C to stop

If all goes well then your console output should look something like the output above. At this point we can navigate to http://localhost:1313/ and see our site. You may need make a few tweaks here and there where the content is referencing myself or my socials. You may have missed something in the config.toml if so, but a quick find+replace will do the trick.

Push to Github

Now that we have an early version of our site ready it is worth checking this into Github so we can save our progress. It will also need to be in Github for the next steps where we deploy our site to Netlify. The steps to do this are as follows

git init
git add -A
git commit -m "first commit"
git branch -M main
git remote add origin 
git remote add origin https://github.com/cameronldroberts/hugo-blog.git
git push -u origin main

Github usually provides you with the steps when you create a new repo but I'll include them incase you can't find them. If you follow the steps above make sure you change the remote origin to your repository. Be sure to know what you're committing into your repository when using git add -A as you could quite easily check in an API key or sensitive information when using it (should be fine for our first drop of code with the blog). I usually use the VSCode Source control tab as it gives a nice way to compare changes.

Deploying to Netlify

My original Gatsby site was deployed to Netlify and I decided to stick with the platform as it just makes it all so easy. We are going to use Github as this is where I host my code but it is possible to use others such as Bitbucket and GitLab although the steps may deviate slightly.

If you haven't already got a Netlify account you can sign up here. This will ask you to authorise with Github as it will require access to the repo you want to deploy.

Once you have authorised Netlify navigate to the "sites" page and click the New site from Git button. This will popup a wizard for you to follow to create a new website referencing a Github repo of your choice. Pick the repository that you just pushed your site to. I chose hugo-blog as this is where I pushed my code. The next page will ask for a few bits of information such as Owner and Branch which are usually auto populated with the correct values. In my project they are cameronldroberts's team and main. For the Basic build settings you have two options

option 1) Fill out the required information with your required build command hugo and publish directory public. Depending on the theme used you may need to specify a minimum version build command

option 2) This is the method I have used and would recommend as it doesn't take much extra effort and everything is all together nicely in your source control. Create the following file in the root of your Github repo in a file called netlify.toml

[build]
publish = "public"
command = "hugo --gc --minify"

[context.production.environment]
HUGO_VERSION = "0.81.0"
HUGO_ENV = "production"
HUGO_ENABLEGITINFO = "true"

[context.split1]
command = "hugo --gc --minify --enableGitInfo"

[context.split1.environment]
HUGO_VERSION = "0.81.0"
HUGO_ENV = "production"

[context.deploy-preview]
command = "hugo --gc --minify --buildFuture -b $DEPLOY_PRIME_URL"

[context.deploy-preview.environment]
HUGO_VERSION = "0.81.0"

[context.branch-deploy]
command = "hugo --gc --minify -b $DEPLOY_PRIME_URL"

[context.branch-deploy.environment]
HUGO_VERSION = "0.81.0"

[context.next.environment]
HUGO_ENABLEGITINFO = "true"

Just before we deploy our site we need to check this into Github quickly.

git add netlify.toml
git commit -m "Add Netlify config"
git push

Once the config file has reached our Github repo hit Deploy site. Netlify will take a few minutes whilst it gets the site deployed but once it has you should get a site link on your Site overview page. Visit the page and tadaah you have deployed your site to Netlify and the world can see.

Some debugging tips if it doesn't quite go to plan

Check the Netlify logs it will usually point out the errors it is struggling with
If you chose option 1 and didn't use the Netlify config file then make sure you are using at least the minimum version of Hugo that your theme requires

Custom domain

Whilst the urls generated by Netlify are completely free and great whilst in dev, if you're creating a proper site I would imagine that you would like to add your own. You can buy a domain through Netlify and by doing this they will configure DNS and provision a wildcard certificate. I bought my domain prior to making the original site so never got one through Netlify. I can imagine this would be the easiest way to add a custom domain to a Netlify site but it isn't too difficult to do so when your domain is purchased elsewhere. You also have the option to use the Netlify DNS and let them handle everything. I think this may be slightly out of scope for this post but if you want to read up on how you can do it then this document is good place to start

If you don't mind a domain that ends with netlify.app then you can change the randomly generated name to something more suitable. Head over to Site settings -> Domain Management and click on the options drop down under Custom domains.

web.dev/measure

Google have provided a pretty cool site which you can use to measure overall performance of your site. I ran both sites through the tool and got the following reports

Hugo	Score	Gatsby	Score
Performance	99	Performance	92
Accessibility	100	Accessibility	97
Best Practices	100	Best Practices	100
SEO	100	SEO	100

According to the tool the Hugo site outperforms the Gatsby one. In defence of the Gatsby site there's a few bits of code in there that I have written to test things out and never finished them or have a few TODO items left so it may not be completely fair race. Having said that the Gatsby site despite being slightly neglected is not performing too badly.

Thanks for reading and I hope you enjoyed the post!

https://www.cameronroberts.dev/

Reading list

Testing out some features from the Golang 1.16 Beta (Embedded files)

cameronldroberts — Fri, 12 Feb 2021 00:37:12 +0000

So with Go 1.16 coming out soon I figured it would be good to talk about a feature that is coming which I thought was pretty cool. This feature is included in the new embed package.

Installing Go 1.16

As of the time of writing Go 1.16 is still in beta so the steps to install it are as follows

go get golang.org/dl/go1.16rc1 
go1.16rc1 download

When it's out of beta you will just need to make sure you have upgraded using your usual upgrade mechanism brew upgrade go or download it.

//go:embed

The embed package coming in 1.16 allows you the ability to embed files as part of the Go binary. This is a pretty cool feature and with so many tools existing to provide this kind of functionality it’s clear that it will be popular.
Some examples are

In action

Now lets see embed in action..
Create a file called main.go and add the following code..

package main

import (
_ "embed"
"fmt"
)

//go:embed hello.txt
var message string

func main() {
    fmt.Println(message)
}

Before we run this code we need to make sure we have a hello.txt that contains our message. This message can be whatever you like but I'm going for the trusty "Hello, World!".

Run the code with the following (if we're still in beta)

go1.16rc1 run main.go

which should output something along the lines of

Hello, World!

Now a more practical example may be embedding a version.txt or some kind of configuration file. Another use case may be to embed assets for a webapp.
The code to do that would look something like this.

package main

import (
    "embed"
    "net/http"
)

//go:embed assets/*
var assets embed.FS

func main() {
    fs := http.FileServer(http.FS(assets))
    http.ListenAndServe(":8080", fs)
}

That is all for today and hopefully you enjoyed the post!

Using the Twitter API to get tweets

cameronldroberts — Sun, 07 Feb 2021 00:48:11 +0000

This post will talk through the steps on how to create your own Twitter bot in Go! We will be making use of go-twitter which is a Go client library for the Twitter API. Big thanks to the developers over there for making an easy to use library.

Prerequisites

Twitter developer account
Valid Golang installation
Basic programming knowledge

Creating a Twitter API key

If you haven't already got a developer account on Twitter you will need to sign up. The steps to do this are documented here.

Once you have an approved developer account head over to the dashboard and create a new Project.

Take note of your API key, API key secret, access token, access token secret as we will need these in a few moments time.

Project setup

mkdir twitter-bot
cd twitter-bot
// Change this to your Github 
go mod init github.com/cameronldroberts/twitter-bot

Go....code!

Open the twitter-bot directory in your favourite editor and create a file named main.go.

Firstly we will focus on authenticating with twitter. We are going to store the keys in environment variables. It's not a good idea to have sensitive information stored in our code as when it reaches our source control (Github, Gitlab, etc) it may be visible to others.

Head over to the developer dashboard page where you should see the project you just created. On the left hand side click the name of your project under Projects & Apps. Navigate to the Keys and tokens page which is where we grab the API keys from.

We need four values CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN and ACCESS_TOKEN_SECRET. These can all be found on the Keys and tokens page. Once you have the values populate the export commands with the right values.

export CONSUMER_KEY=<API_KEY_VALUE>
export CONSUMER_SECRET=<API_KEY_SECRET_VALUE>
export ACCESS_TOKEN=<ACCESS_TOKEN_VALUE>
export ACCESS_TOKEN_SECRET=<ACCESS_TOKEN_SECRET_VALUE>

Once we have exported the environment variables we need to read them in via our Go code. The following code will do that and it will be the method we use when the code is complete

package main
import (
    "fmt"
    "os"
)

type Credentials struct {
    ConsumerKey       string
    ConsumerSecret    string
    AccessToken       string
    AccessTokenSecret string
}

func main() {
    creds := Credentials{
        ConsumerKey:       os.Getenv("CONSUMER_KEY"),
        ConsumerSecret:    os.Getenv("CONSUMER_SECRET"),
        AccessToken:       os.Getenv("ACCESS_TOKEN"),
        AccessTokenSecret: os.Getenv("ACCESS_TOKEN_SECRET"),
    }

     fmt.Printf("%+v\n",creds)
}

This bit of the code can be divided into three sections

Imports This is where we import other packages that we make use of in our code. It's only a short list at the moment but we will be adding a few by the time we have completed the Twitter bot!
Struct We define a struct to store the keys that we need to use for authenticating with Twitter.
main function This function is slightly special in that it is the entrypoint and will be called automatically when we run our program. For now we are just going to prove that we can read in our environment variables.

Copy the code snippet into main.go and run it using the following command

go run main.go

This should output something similar to this

{randomvalue1 randomvalue2 randomvalue3 randomvalue4}

In your case each of the values should be referring to the keys from twitter.

Authenticating with Twitter

Now that we have exported our environment variables and are able to read them in we are ready to authenticate with Twitter.

func getClient(creds *Credentials) (*twitter.Client, error) {

    // These values are the API key and API key secret
    config := oauth1.NewConfig(creds.ConsumerKey, creds.ConsumerSecret)
    // These values are the consumer access token and consumer access token secret
    token := oauth1.NewToken(creds.AccessToken, creds.AccessTokenSecret)
    httpClient := config.Client(oauth1.NoContext, token)
    client := twitter.NewClient(httpClient)

    verify := &twitter.AccountVerifyParams{
        SkipStatus:   twitter.Bool(true),
        IncludeEmail: twitter.Bool(true),
    }
    user, _, err := client.Accounts.VerifyCredentials(verify)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    // print out the Twitter handle of the account we have used to authenticate with 
    fmt.Println("Successfully authenticated using the following account : ", user.ScreenName)
    return client, nil
}

We can now call this function from within our main function. Replace this line(we don't need to log the credentials out anymore)

fmt.Printf("%+v\n",creds)

with

client, err := getClient(&creds)
if err != nil {
    fmt.Println(err)
    os.Exit(1)
}

Search tweets

As I have mentioned previously the go-twitter client library makes it nice and easy to talk to the Twitter API in Go! Let's create our next function where we make use of the search functionality

func searchTweets(client *twitter.Client) error {

    search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
        Query: "bonjour",
    })

    if err != nil {
        fmt.Println(err)
        return err
    }
    fmt.Println("search : ", search)
    return nil
}

Add the following line to our main() function (at the bottom)

searchTweets(client)

and then run the code with go run main.go

Your terminal window will turn into what looks like a wall of text that doesn't make a lot of sense. This code works but there's definitely room for improvement! All of the tweets that were returned were in French (Not surprising given the search parameter) and the big wall of text is not very readable. Let's make some improvements to the searchTweets() function.

Improving our search function

I'm not sure about you but unfortunately I'm unable to speak French so the first change we'll make is to add a language to the search parameters. We do this by adding the following parameter for English Lang: "en",. This will bring back tweets where Twitter has detected the language to be English. Let's change our search parameter to become the following

search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
    Query: "bonjour",
    Lang:  "en",
})

The second change is to parse the interesting bits of each tweet into a struct so we can ignore the bits we don't care about and more clearly see the bits we do care about! Let's try and keep things anonymous by only grabbing the tweet likes, retweets and the tweet itself. To do this let's create another struct but this time it will hold tweet data instead of credentials

type TweetData struct {
    Tweet         string
    LikeCount    int
    RetweetCount int
}

When we use the client to search tweets we get a twitter.Search object back which has an array of tweets and metadata. To grab out the values we want to keep we will loop over the array of tweets creating a struct to hold the data. We will print each struct so it makes it more readable than the previous wall of text!

New and improved...

func searchTweets(client *twitter.Client) error {
    search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
        Query: "bonjour",
        Lang:  "en",
    })

    if err != nil {
        fmt.Println(err)
        return err
    }

    for _, v := range search.Statuses {
        tweet := TweetData{
            Tweet:        v.Text,
            LikeCount:    v.FavoriteCount,
            RetweetCount: v.RetweetCount,
        }
        fmt.Printf("%+v\n", tweet)
    }
    return nil
}

Replace the existing searchTweets() with the above snippet of code. Feel free to add/remove/change the SearchTweetParams to something you find more interesting. You could change the query parameter to something else (maybe "Formula 1"). You could also add on some additional parameters to the query.

At the moment this is a pretty simple use case but hopefully it gives you a foundation to build on. We could go on and build up an array of tweets and do some kind of processing on them. We could send tweets via the client when a certain condition is true.

TLDR

If you just want to skip ahead to the completed code snippet or want to use the completed snippet for reference, here it is. If you come straight here don't forget to make sure you have your API keys setup.

package main

import (
    "fmt"
    "os"

    "github.com/dghubble/go-twitter/twitter"
    "github.com/dghubble/oauth1"
)

type Credentials struct {
    ConsumerKey       string
    ConsumerSecret    string
    AccessToken       string
    AccessTokenSecret string
}

type TweetData struct {
    Tweet        string
    LikeCount    int
    RetweetCount int
}

func main() {
    creds := Credentials{
        ConsumerKey:       os.Getenv("CONSUMER_KEY"),
        ConsumerSecret:    os.Getenv("CONSUMER_SECRET"),
        AccessToken:       os.Getenv("ACCESS_TOKEN"),
        AccessTokenSecret: os.Getenv("ACCESS_TOKEN_SECRET"),
    }

    client, err := getClient(&creds)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    searchTweets(client)
}

func getClient(creds *Credentials) (*twitter.Client, error) {

    // These values are the API key and API key secret
    config := oauth1.NewConfig(creds.ConsumerKey, creds.ConsumerSecret)
    // These values are the consumer access token and consumer access token secret
    token := oauth1.NewToken(creds.AccessToken, creds.AccessTokenSecret)
    httpClient := config.Client(oauth1.NoContext, token)
    client := twitter.NewClient(httpClient)

    verify := &twitter.AccountVerifyParams{
        SkipStatus:   twitter.Bool(true),
        IncludeEmail: twitter.Bool(true),
    }
    user, _, err := client.Accounts.VerifyCredentials(verify)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    // print out the Twitter handle of the account we have used to authenticate with
    fmt.Println("Successfully authenticated using the following account : ", user.ScreenName)
    return client, nil
}

func searchTweets(client *twitter.Client) error {
    search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
        Query: "Formula 1",
        Lang:  "en",
    })

    if err != nil {
        fmt.Println(err)
        return err
    }

    for _, v := range search.Statuses {
        tweet := TweetData{
            Tweet:        v.Text,
            LikeCount:    v.FavoriteCount,
            RetweetCount: v.RetweetCount,
        }
        fmt.Printf("%+v\n", tweet)
    }
    return nil
}

That's it for this post, hopefully you enjoyed it and it made sense!
https://www.cameronroberts.dev/

Consuming a REST API using Golang

cameronldroberts — Sun, 31 Jan 2021 22:28:27 +0000

This post will talk about how to consume a REST API using Go. We will go through steps to setup the Go project, Go Modules used and how we run the code.

Prerequisites

Valid Golang installation

If you need instructions on how to install it this is a good place to start

Introduction

This is a popular task to complete as developer so I figured it would be a good one to start with. The API that will be used in this post is icanhazdadjoke as you can probably guess from the URL it will return a joke when called. To get started let's create a new directory that will hold the project.

Project setup

mkdir golang-api
cd golang-api
go mod init github.com/cameronldroberts/golang-api
touch main.go

We are now ready to get started with the coding! Open the golang-api project in your favourite editor (VSCode for me) and open main.go which is where the code will live.

Imports

To start with we will cover the imports which is how we pull in other Go modules. In Go a module is a collection of one or more packages which contain related code. In order to call the API we will be using the following four. Depending on the editor (and settings) you use the imports will be handled automatically and therefore you may not need to do the following step of manually adding the imports.

package main
import (
 "encoding/json"
 "fmt"
 "io/ioutil"
 "net/http"
)

Example response

This in an example response that we get from the API when calling it. As we know the structure of the JSON response that we will receive we can map this into a struct.

{
"id": "XgVnOK6USnb",
"joke": "What did the calculator say to the student? You can count on me",
"status": 200
}

Struct

The struct is fairly basic so in this instance it wouldn't be too much work to map from JSON to the struct below.

type Response struct {
 ID     string `json:"id"`
 Joke   string `json:"joke"`
 Status int    `json:"status"`
}

In the event that we have a much larger JSON response this can become quite a time consuming process. Not to worry as there's a useful tool called
JSON-to-Go which handles the conversion.

Code

Finally for the function that calls the API and handles the response. When developing with Go it would not be advised to have function logic inside main() as this is meant to be the entry point for your program. For the purpose of this article we will be placing the code in main but it's not advised when developing in the real world. More on that here

func main() {
 fmt.Println("Calling API...")
client := &http.Client{}
 req, err := http.NewRequest("GET", "https://icanhazdadjoke.com/", nil)
 if err != nil {
  fmt.Print(err.Error())
 }
 req.Header.Add("Accept", "application/json")
 req.Header.Add("Content-Type", "application/json")
 resp, err := client.Do(req)
defer resp.Body.Close()
 bodyBytes, err := ioutil.ReadAll(resp.Body)
 if err != nil {
  fmt.Print(err.Error())
 }
var responseObject Response
 json.Unmarshal(bodyBytes, &responseObject)
 fmt.Printf("API Response as struct %+v\n", responseObject)
}

Firstly we create a http client and create our http request
We then add a couple of http headers to our request before sending the http request with resp, err := client.Do(req)
We read in the response and then we unmarshal it into our response struct
Finally we print out the response

Running the project

To run the project use the following command

go run main.go

This will compile and run the main.go file. If all has gone well you should have a joke printed into your terminal. The output should look something like

go run main.go
Calling API...
API Response as struct {ID:5h399pWLmyd Joke:What did the beaver say to the tree? It's been nice gnawing you. Status:200}

TLDR

Completed code snippet for consuming the canihazdadjoke REST API using Go!

package main
import (
 "encoding/json"
 "fmt"
 "io/ioutil"
 "net/http"
)
type Response struct {
 ID     string `json:"id"`
 Joke   string `json:"joke"`
 Status int    `json:"status"`
}
func main() {
 fmt.Println("Calling API...")
client := &http.Client{}
 req, err := http.NewRequest("GET", "https://icanhazdadjoke.com/", nil)
 if err != nil {
  fmt.Print(err.Error())
 }
 req.Header.Add("Accept", "application/json")
 req.Header.Add("Content-Type", "application/json")
 resp, err := client.Do(req)
defer resp.Body.Close()
 bodyBytes, err := ioutil.ReadAll(resp.Body)
 if err != nil {
  fmt.Print(err.Error())
 }
var responseObject Response
 json.Unmarshal(bodyBytes, &responseObject)
 fmt.Printf("API Response as struct %+v\n", responseObject)
}

and thats it for the first post! Hopefully you found it helpful.
https://www.cameronroberts.dev/