Deploy a Go Gin Application on Koyeb
Tags: webdev, programming, go, tutorial
Published: 2022-01-12 13:26:21


This guide explains how to deploy a Golang Gin application on the Koyeb serverless platform using git-driven deployment.

[Gin](https://github.com/gin-gonic/gin) is a web framework written in Golang focusing on performance and simplicity.

By deploying a Go Gin application on [Koyeb](//koyeb.com) using git-driven deployment, each time you push your code changes, your application will be automatically built and promoted once the built and health checks are completed.
Once your application is deployed, it will benefit from Koyeb native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network with zero configuration.

## Requirements

To successfully follow and complete this guide, you need:
- The Go programming language installed
- A [Koyeb account](https://app.koyeb.com) to deploy and run the Go web API
- A [**GitHub account**](//github.com/)


## Steps

To successfully complete this guide and deploy the Go API on Koyeb, you need to follow these steps:

1. [**Building a minimalist Go Gin application**](#building-the-go-api-using-gin)
2. [**Deploy the Go Gin application on Koyeb**](#deploy-the-dockerized-go-api-on-koyeb)

## Building a minimalist Go Gin application

To get started, create a new directory to build our sample application:

```bash
mkdir ~/gin-demo
cd ~/gin-demo
```

Next, run `go mod init` to create a `go.mod` file and track your code's dependencies.
As you add dependencies, the `go.mod` file will list the versions your code depends on allowing you to keep your builds reproducible and giving you direct control over which module versions to use.

In your project folder, create a new file named `app.go` with the following content inside:

```go
package main

import (
  "fmt"
  "os"

  "github.com/gin-gonic/gin"
)

func main() {
  port := os.Getenv("PORT")

  if port == "" {
    port = "8000"
  }

  r := gin.Default()

  r.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "Hello, world!",
    })
  })

  r.GET("/:name", func(c *gin.Context) {
    name := c.Param("name")

    c.JSON(200, gin.H{
      "message": fmt.Sprintf("Hello, %s!", name),
    })
  })

  r.Run(fmt.Sprintf(":%s", port))
}
```

The code above launches a Gin server listening on port 8000 by default with two API routes configured:

- `/` returning "Hello, world!"
- `/:name` returning "Hello, :name!" where :name is the string passed in parameter, i.e /john will return "Hello, john!".

Then, in your terminal execute `go mod tidy` to add missing modules required by our project and add `github.com/gin-gonic/gin` as a project dependency.

You can now run the application locally by running `go run server.go` and navigating in your browser at `http://localhost:8000`.

## Deploy the Go Gin application on Koyeb

Next, initialize a new git repository on your local machine running:

```bash
git init
```

Add a new remote pointing to your GitHub repository:

```
git remote add origin git@github.com:<YOUR_GITHUB_USERNAME>/<YOUR_GITHUB_REPOSITORY>.git
```

Last, add the `app.go`, `go.mod` and `go.sum` files to your repository and commit & push your changes:

```bash
git add app.go go.mod go.sum
git commit -m "Initial commit"
git push -u origin main
```

Go to the Koyeb [Control Panel](https://app.koyeb.com) and click the Create App button to go to the App creation page:

1. Select GitHub as the deployment method to use
2. In the repositories list, select the repository containing your Go Gin application
3. Specify the branch to deploy, in this case, `main`
4. Give your App a name, i.e go-gin-on-koyeb, and click Create App.

Then, click the **Create App** button to create and deploy the application. You land on the deployment page where you can follow the progress of your Go Gin application's deployment. Once the build and deployment are completed, you can access your application by clicking the App URL ending with `koyeb.app` in the Koyeb control panel.

If you want to learn about how Koyeb automatically builds your Go Gin applications from git, make sure to read our [**how we build from git**](//koyeb.com/docs/apps/build-from-git) documentation.

## Conclusion

In this guide, you learned how to deploy a Go Gin application on Koyeb using git. Each change you push to your repository will automatically trigger a new build and deployment on the Koyeb Serverless Platform.
Your changes then go live as soon as the deployment passes all necessary health checks. In case of a failure during one of your deployments, we ensure to keep the latest working deployment active so your application is always up and running.

If you have any questions or suggestions to improve this guide, feel free to reach out to us on **[Slack](https://slack.koyeb.com/)**.