RESTful API Development with Go: Part 1
Published: 2024-05-13 15:10:04

# RESTful API Development with Go: Part 1

Welcome to the first part of our series on creating RESTful APIs using Go. In this guide, we will walk you through building a simple API that follows the principles of Representational State Transfer (REST). By the end of this tutorial, you'll have a good understanding of how to create basic CRUD operations for your API endpoints.

## Prerequisites
Before getting started, make sure you have Go installed. You can download and install it from [here](https://golang.org/dl/).

## Setting up Your Project
To begin, create a new directory on your machine for your project. Open your terminal or command prompt and navigate to that directory.

Once inside the project folder, use `go mod init` command to initialize our module.
```shell
go mod init example.com/rest-api-demo
```

This will create a `go.mod` file in your project's root directory.

Next, let's create our main.go file using any text editor or an integrated development environment (IDE) like Visual Studio Code:

```shell
touch main.go  
```

Now open `main.go` in your chosen editor and let's start coding!

## Importing Dependencies
Every Go application starts with importing required packages and dependencies. For our RESTful API development, we will need some important packages like `"fmt"`, `"net/http"`, and `"github.com/gorilla/mux"`.

Firstly add standard library package imports:
```go
import (
    "fmt"
    "net/http"
)
```
Then import the Gorilla Mux package:
```Go
import (
    "github.com/gorilla/mux"
)
```

Remember to save changes before moving forward!

## Creating Our First Route

To handle HTTP requests effectively in Go, we're going to use Gorilla Mux as our router. Let's create our first route:

```go
func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to our RESTful API!")
}

func main() {
    // Create a new instance of the mux router
    router := mux.NewRouter()

    // Define your routes here

	router.HandleFunc("/", homeHandler).Methods("GET")

	// Start the server on port 8080
	http.ListenAndServe(":8080", router)
}
```

The `homeHandler` function will be executed whenever a GET request is made to the root URL ("/") of our API. In this case, it simply sends a welcome message as the response.

## Running Your API Server

Now that we have defined our first route and basic handler function, let's run our Go application. In your terminal or command prompt, type:

```shell
go run main.go
```

You should see something like this:
```
Starting server on localhost:8080...
```

Congratulations! You've just created your first RESTful API using Go.

## Testing Your Endpoint

To test if everything is working correctly, open your web browser and go to `http://localhost:8080`. You should see the welcome message displayed in your browser window.

## Conclusion

In this article, you learned how to set up a basic project structure for developing RESTful APIs with Go. We also introduced Gorilla Mux as our routing package and created our very first endpoint.

In the next part of this series, we will dive deeper into handling different HTTP methods (POST, PUT/PATCH, DELETE), interacting with databases using Go's built-in SQL packages or ORMs like GORM and more advanced concepts such as authentication and authorization for secure APIs development.

Stay tuned for Part 2 where we'll build upon what we learned today!