Skip to main content

Golang

Getting an application running on Boltic is essentially working out how to package it as a deployable image. Once packaged, it can be deployed to the Boltic global application platform.

In this guide we’ll learn how to deploy a Golang application on Boltic.

Note

Before starting this guide, ensure you have a Boltic account and have created a serverless app in your account.

Initial Local Setup​

Make sure that Golang is installed on your local machine.

This allows you to run your project locally, and test that it works, before deploying it to Boltic.

tip

We recommend the latest supported versions of Golang.

Create a new directory for your Golang application and navigate into it:

# Create a new project directory
mkdir golang-app

# Navigate to the project directory
cd golang-app

Run an HTTP Server​

In this guide we recreate and deploy this minimal Golang application to demonstrate how quickly Golang apps can be deployed to Boltic!

tip

You can follow the guide to recreate the app or just git clone https://github.com/bolticio/serverless-samples.git to get a local copy.

Make sure to navigate to appropriate directory using: cd serverless-samples/golang/applications/docker/hello-world

We assume you already have Golang installed.

Create the HTTP Server​

The hello-world application is, as you’d expect for an example, very minimal.

Create a new file main.go and add the following code:

# main.go
package main

import (
    "encoding/json"
    "log"
    "net/http"
    "strings"
)

// Define the handler function
func handler(context http.ResponseWriter, event *http.Request) {
    // Extract the path from the request URL and capitalize the first letter
    path := strings.TrimPrefix(event.URL.Path, "/")
    if path == "" {
        path = "World"
    } else {
        path = strings.Title(strings.ToLower(path))
    }

    // Initialize a map to hold the response body
    response := map[string]string{
        "message": "Hello, " + path + "!", // Set the message to "Hello, <path>!"
    }

    // Set the Content-Type header to application/json
    context.Header().Set("Content-Type", "application/json")

    // Encode the response map into JSON and write it to the response
    json.NewEncoder(context).Encode(response)
}

func main() {
    // Define the port to listen on
    port := ":8080"

    // Print the message when the server starts listening
    log.Println("Example app listening on port 8080!")

    // Create a new HTTP server
    http.HandleFunc("/", handler)

    // Start the server
    http.ListenAndServe(port, nil)
}

Start the Development Server​

Golang apps are run with the go run command:

go run main.go
Example app listening on port 8080!

If you open http://127.0.0.1:8080/ in your web browser, it displays Hello, World!.

If you open, for example, http://127.0.0.1:8080/fynd , it displays Hello, Fynd!.

Before Deployment ​

A few more steps are necessary before deploying the app.

In order to deploy the app to Boltic, you need to create a boltic.yaml/boltic.toml file in the root of your project. This file contains the configuration for the deployment. Read more about the Application Configuration for more information.

app: golang-docker-app-sample
region: asia-south1
entrypoint: "main.go"

build:
  builtin: dockerfile
  ignorefile: .gitignore

env:
  PORT: '8080'

The system will always refer to this file in the current directory if it exists, specifically for the app name/value at the start. That name will be used to identify the application to the Boltic service. The rest of the file contains settings to be applied to the application when it deploys:

  • primary_region: it configures where the primary region is, used to create the application;
  • builtin: it configures the builder to use the built-in Dockerfile strategy, which uses a system generated generic Dockerfile to build the application;
  • env: it configures the environment variables to set in the application.
info

This application is being built using the builtin strategy. This strategy uses a system-generated generic Dockerfile to build the application. The ignorefile key is used to specify the name of the file that contains the list of files and directories to be ignored during the build process. The ignorefile key is optional and if not provided, the default value is .dockerignore. For more information on the available builders in Boltic, check out the Builders page.

If you would rather like to use buildpacks to build your application, you can use the following configuration:

app: golang-docker-app-sample
region: asia-south1
entrypoint: main.go

build:
  builtin: dockerfile
  ignorefile: .gitignore

env:
  PORT: '8080'
info

This application will now be built using the paketo-buildpacks/golang buildpack. Learn more about Paketo Buildpacks.

Now, let’s move on to deploying this app to Boltic.

Deploy to Boltic​

We are now ready to deploy our app to Boltic. Ensure you have a Boltic account and have created a serverless app in your account.

tip

In order to clone the repository created for your app after registering it on the console, make sure you have added an SSH key to your Boltic account. You can find the instructions on how to add an SSH key in the SSH Keys section.

Initialize a new git repository in your project:

git init --initial-branch=main

Add a new origin to your local git repository:

git remote add boltic GIT_URL_DISPLAYED_IN_THE_CONSOLE

Commit your changes and push them to the bolt remote:

git add .
git commit -m "serverless initialized"
git push bolt main

The deployment process will start automatically. You can check the status of the deployment in the Boltic console. If everything goes well, the deployment will finish successfully in a few minutes. You can also check the logs to see the if there are any errors. Once the deployment is finished, you can access your app through the URL provided in the Boltic console.

info

The URL will be in the format https://<region>.api.boltic.io/apps/<system-version>/<org-id>/<app-id>.

Run a Function​

In this guide we recreate and deploy this sample golang function to demonstrate how easy it is to setup serverless Golang functions on Boltic!

tip

You can follow the guide to recreate the app or just git clone https://github.com/bolticio/serverless-samples.git to get a local copy.

Make sure to navigate to appropriate directory using: cd serverless-samples/golang/functions/docker/hello-world

note

Currently there is not native way to test serverless functions locally. You can test the function by directly deploying it to Boltic.

We assume you already have Golang installed.

Create the Function​

The hello-world application is, as you’d expect for an example, very minimal.

Create a new file handler.go and add the following code:

# handler.go
package main

// Import necessary packages
import (
 "encoding/json"
 "net/http"
)

// Define the handler function
func handler(context http.ResponseWriter, event *http.Request) {
 // Initialize a map to hold the response body
 response := map[string]string{
  "message": "Hello, World!", // Set the message to "Hello, World!"
 }

 // Set the Content-Type header to application/json
 context.Header().Set("Content-Type", "application/json")

 // Encode the response map into JSON and write it to the response
 json.NewEncoder(context).Encode(response)
}

Before Deployment ​

A few more steps are necessary before deploying the function.

The handler will be the entry point for the function. The handler is the function that will be called when the function is invoked. The handler should be in the format module_name.function_name. The module_name is the name of the file where the function is defined and the function_name is the name of the function that will be called. Checkout handler for now information

app: golang-buildpack-func-sample
region: asia-south1
handler: "handler.handler"

build:
  builtin: dockerfile
  ignorefile: .gitignore

Testing the function locally​

To test any boltic serverless function locally please refer boltctl serverless test command.

Deploy to Boltic​

Deployment of the function is similar to deploying an application. You can deploy the function by following the same steps as mentioned in the Deploy to Boltic section.

Congrats! You have successfully built, deployed, and connected to your first Golang application/function on Boltic. 🚀