Deploy a Golang App

Deploy a Golang application on Koyeb and benefit from Koyeb native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network with zero configuration.

This guide explains how to deploy a Golang application on Koyeb using:

  1. Git-driven deployment to automatically build and deploy a new version of your application each time a change is detected on your branch.
  2. Pre-built containers you can deploy from any public or private registry.

To successfully follow this documentation, you will need to have a Koyeb account. You can optionally install the Koyeb CLI if you prefer to follow this guide without leaving the terminal.

You can deploy and preview the sample Python Flask application that we will run on Koyeb in this guide using the Deploy to Koyeb button below.

Deploy to Koyeb

You can access the repository used for this documentation here.

Create the Golang app

Get started by creating a minimalistic Golang application that we will deploy on Koyeb. You will need Go installed on your machine.

In your terminal, run the following commands to create the directory that will hold the application code:

mkdir example-golang cd example-golang

Koyeb detects Go applications when one of the following requirements is met. In this guide, we will use Go module to trigger the detection.

Run the go mod init command with your module path, here we use When you publish a module, this must be a path from which your module can be downloaded by Go tools, such as your code's repository.

$ go mod init go: creating new go.mod: module

Create a new file main.go and copy the following code into it:

package main import ( "fmt" "log" "net/http" "os" ) func main() { port := os.Getenv("PORT") if port == "" { port = "8080" } http.HandleFunc("/", HelloHandler) log.Println("Listening on port", port) log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil)) } func HelloHandler(w http.ResponseWriter, _ *http.Request) { fmt.Fprintf(w, "Hello from Koyeb") }

The code above runs an HTTP server using the standard net/http library and responds Hello from Koyeb to GET / requests.

Run the Golang app locally

Launch the application locally to make sure everything is running as expected.

go run main.go

You can now access the application at http://localhost:8080.

Deploy the Golang app on Koyeb using git-driven deployment

In the project directory, initialize a new git repository by running the following command:

git init

We will use this repository to version the application code and push the changes to a GitHub repository. If you don't have an existing GitHub repository to push the code to, you can create a new one and run the following commands to commit and push changes to your GitHub repository:

git add . git commit -m "Initial commit" git remote add origin<YOUR_GITHUB_USERNAME>/<YOUR_REPOSITORY_NAME>.git git push -u origin main

Via the Koyeb control panel

To deploy the Golang app on Koyeb, using the control panel follow the steps below:

  1. Create a new Koyeb App named example-golang
  2. Select GitHub as the deployment option
  3. Choose the GitHub repository and branch contaning your application code
  4. Name your service, for instance golang-service
  5. Click the Create service button.

A Koyeb App and Service have been created. Your application is now going to be built and deployed on Koyeb. Once the build has finished, you will be able to access your application running on Koyeb by clicking the URL ending with

Via Koyeb CLI

To deploy the Golang app on Koyeb using the Koyeb CLI, run the following command in your terminal:

koyeb app init example-golang \ --git<YOUR_GITHUB_USERNAME>/<YOUR_REPOSITORY_NAME> \ --git-branch main \ --ports 8080:http \ --routes /:8080 \ --env PORT=8080

Make sure to replace <YOUR_GITHUB_USERNAME>/<YOUR_REPOSITORY_NAME> with your GitHub username and repository name.

Access deployment logs

To track the app deployment and visualize build logs, execute the following command:

koyeb service logs golang-example/golang-example -t build

Access your app

Once the deployment of your application has finished, you can retrieve the public domain to access your application by running the following command:

$ koyeb app get golang-example ID NAME DOMAINS CREATED AT 55d75993 golang-example [""] 20 Sep 22 09:55 UTC

Access runtime logs

With your app running, you can track the runtime logs by running the following command:

koyeb service logs golang-example/golang-example -t runtime

Deploy the Golang app on Koyeb using a pre-built container

Alternatively to using git-driven deployment, you can deploy a pre-built container from any public or private registry. This can be useful if your application needs specific system dependencies or you need more control over how the build is performed.

To dockerize the Golang application, create a Dockerfile in your project root directory and copy the content below:

FROM golang:1.19-alpine AS builder WORKDIR /app COPY . . RUN go mod download RUN go build -o ./example-golang ./main.go FROM alpine:latest AS runner WORKDIR /app COPY --from=builder /app/example-golang . EXPOSE 8080 ENTRYPOINT ["./example-golang"]

The Dockerfile above provides the minimum requirements to run the Golang application. You can easily extend it depending on your needs.

To build and push the Docker image to a registry and deploy it on Koyeb, refer to the Deploy an app from a Docker image.