FastHTTP

To make using Scale Functions from FastHTTP webservers easier, we’ve created a FastHTTP Adapter that allows you to use a compiled Scale Function as a handler for your FastHTTP server.

​

Getting Started

First, you’ll need a Golang application that uses the FastHTTP library. If you don’t have a Golang application, you can use the following example to get started:

package main

import (
    "fmt"
    "log"
    "github.com/valyala/fasthttp"
)

func main() {
    log.Fatal(fasthttp.ListenAndServe(":8080", func (ctx *fasthttp.RequestCtx) {
	    fmt.Fprintf(ctx, "Hello, World!")
    }))
}

Next, install the Scale Runtime and the Scale HTTP Adapters package:

go get github.com/loopholelabs/scale && go get github.com/loopholelabs/scale-http-adapters

Now you’re ready to start using Scale Functions in your Golang application!

​

Embedding a Scale Function

To get started, let’s create a Scale Function that returns a simple ‘Hello World’ message. This is as simple as running the following command:

scale fn new hello

This will create a new Scale Function in the current directory. You can see the code for the Scale Function in the scale.go file that gets generated. The Scale Function is a simple HTTP handler that returns a Hello World message:

//go:build tinygo || js || wasm
package scale

import (
	signature "github.com/loopholelabs/scale-signature-http"
)

func Scale(ctx *signature.Context) (*signature.Context, error) {
	ctx.Response().SetBody("Hello, World!")
	return ctx
}

Now lets build the Scale Function and export it locally:

scale build

At this point, we can choose to either embed the Scale Function into our Golang application at build time or import it using the Scale Registry at runtime. In this example we’ll embed the Scale Function into our Golang application at build time, but you can learn how to import the Scale Function from the Scale Registry using our Importing Scale Functions guide.

Run the following command to export the Scale Function locally:

scale function export hello:latest .

This will create a hello-latest.scale file in the current directory. Now we have everything we need to import the Scale Function into our Golang application.

To import the Scale Function into our Next.js App, it’s as simple as using the native import statement:

package main

import (
    "fmt"
    "log"
	"embed"
	"io"
    "github.com/valyala/fasthttp"
	scale "github.com/loopholelabs/scale/go"
	adapter "github.com/loopholelabs/scale-http-adapters/fasthttp"
    "github.com/loopholelabs/scalefile/scalefunc"
)

//go:embed hello-latest.scale
var embeddedFunction []byte

func main() {
	sf := new(ScaleFunc)
	_ = sf.Decode(embeddedFunction)

	r, _ := scale.New(context.Background(), []*scalefunc.ScaleFunc{sf})
    handler := adapter.New(nil, r)

     log.Fatal(fasthttp.ListenAndServe(":8080", handler.Handle))
}

Now we can run our Golang application and test out our Scale Function:

go run main.go