Setup Basic Kong Configuration

Create the kong.yml and docker-compose.yml files. This example uses https://reqres.in/api/users/1 as a mock service. The goal is to forward requests sent to test-service's test-route to the mock service URL and return the response.

kong.yml

_format_version: "3.0"

services:
  - name: test-service
    url: https://reqres.in/api/users/1
    routes:
      - name: test-route
        paths:
          - /
        strip_path: false

docker-compose.yml

name: kong-go-plugin

services:
  kong:
    container_name: kong
    image: kong:latest
    volumes:
      - ./kong.yml:/kong/declarative/kong.yml
    environment:
      - KONG_DATABASE=off
      - KONG_DECLARATIVE_CONFIG=/kong/declarative/kong.yml
      - KONG_PROXY_ACCESS_LOG=/dev/stdout
      - KONG_ADMIN_ACCESS_LOG=/dev/stdout
      - KONG_PROXY_ERROR_LOG=/dev/stderr
      - KONG_ADMIN_ERROR_LOG=/dev/stderr
      - KONG_ADMIN_LISTEN=0.0.0.0:8001
      - KONG_ADMIN_GUI_URL=http://localhost:8002
    ports:
      - "8000:8000"
      - "8443:8443"
      - "8001:8001"
      - "8444:8444"
      - "8002:8002"
      - "8445:8445"
      - "8003:8003"
      - "8004:8004"

Deploy Basic Kong Configuration

Start Kong with this command:

docker compose up -d

Test the setup by sending a request to Kong:

curl http://localhost:8000

The mock service should respond with:

{"data":{"id":1,"email":"george.bluth@reqres.in","first_name":"George","last_name":"Bluth","avatar":"https://reqres.in/img/faces/1-image.jpg"},"support":{"url":"https://contentcaddy.io?utm_source=reqres&utm_medium=json&utm_campaign=referral","text":"Tired of writing endless social media content? Let Content Caddy generate it for you."}}

Create the Go Plugin

Create a file named plugin.go that adds a custom header to the response:

go mod init test-plugin
go get github.com/Kong/go-pdk
go get github.com/Kong/go-pdk/server

package main

import (
    "github.com/Kong/go-pdk"
    "github.com/Kong/go-pdk/server"
)

const (
    version  = "0.0.1"
    priority = 1
)

type Config struct {
    Message string `json:"message"`
}

func New() interface{} {
    return &Config{}
}

func (c *Config) Access(kong *pdk.PDK) {
    kong.Response.AddHeader("X-Test-Header", c.Message)
}

func main() {
    _ = server.StartServer(New, version, priority)
}

This plugin accepts a message configuration parameter and adds it as a value in the X-My-Header response header. The Access function is called during Kong's request processing lifecycle. The plugin version ("0.0.1") and priority (1) are defined as constants - Kong executes plugins in order from highest to lowest priority. For more advanced features, check the official documentation's Write Plugins in Go section.

Compile the Plugin

Build the plugin, cross-compiling is necessary unless you are developing on Linux, since Kong runs in a Linux container.

go mod tidy
GOOS=linux go build -o test-plugin plugin.go

Update Kong Configuration

Update kong.yml to add the plugin to the test service:

_format_version: "3.0"

services:
  - name: test-service
    url: https://reqres.in/api/users/1
    routes:
      - name: test-route
        paths:
          - /
        strip_path: false
    plugins:
      - name: test-plugin
        config:
          message: "Test message!"

plugins:
  - name: test-plugin
    enabled: true

Modify docker-compose.yml to copy the compiled plugin into the Kong container and set environment variables to enable and configure the plugin:

name: kong-go-plugin

services:
  kong:
    container_name: kong
    image: kong:latest
    volumes:
      - ./kong.yml:/kong/declarative/kong.yml
      - ./test-plugin:/usr/local/bin/test-plugin
    environment:
      - KONG_DATABASE=off
      - KONG_DECLARATIVE_CONFIG=/kong/declarative/kong.yml
      - KONG_PROXY_ACCESS_LOG=/dev/stdout
      - KONG_ADMIN_ACCESS_LOG=/dev/stdout
      - KONG_PROXY_ERROR_LOG=/dev/stderr
      - KONG_ADMIN_ERROR_LOG=/dev/stderr
      - KONG_ADMIN_LISTEN=0.0.0.0:8001
      - KONG_ADMIN_GUI_URL=http://localhost:8002
      - KONG_PLUGINS=test-plugin
      - KONG_PLUGINSERVER_NAMES=test-plugin
      - KONG_PLUGINSERVER_TEST_PLUGIN_SOCKET=/usr/local/kong/test-plugin.socket
      - KONG_PLUGINSERVER_TEST_PLUGIN_START_CMD=/usr/local/bin/test-plugin
      - KONG_PLUGINSERVER_TEST_PLUGIN_QUERY_CMD=/usr/local/bin/test-plugin -dump
    ports:
      - "8000:8000"
      - "8443:8443"
      - "8001:8001"
      - "8444:8444"
      - "8002:8002"
      - "8445:8445"
      - "8003:8003"
      - "8004:8004"

Deploy with the Plugin

Restart the container with the updated configuration:

docker compose down
docker compose up -d

Test the plugin by sending a request with verbose output to see the custom header:

curl -v http://localhost:8000

The response should contain the custom header along with the data:

...
< X-Test-Header: Test message!
...
{"data":{"id":1,"email":"george.bluth@reqres.in","first_name":"George","last_name":"Bluth","avatar":"https://reqres.in/img/faces/1-image.jpg"},"support":{"url":"https://contentcaddy.io?utm_source=reqres&utm_medium=json&utm_campaign=referral","text":"Tired of writing endless social media content? Let Content Caddy generate it for you."}}

The final project layout:

.
├── docker-compose.yml
├── go.mod
├── go.sum
├── kong.yml
├── plugin.go
└── test-plugin

This guide demonstrates developing a custom Kong plugin with Go. This simple example can serve as a starting point for more complex plugin development.

I assume you already have an Azure IoT Hub with at least one device added to it. You'll need three pieces of information to use this code:

• Your IoT Hub name

• Your device ID

• Your device key (the primary key that was automatically generated when you added the device)

For implementing MQTT connectivity, we'll use the Eclipse Paho MQTT Go client library.

Generating SAS (Shared Access Signature) Token

The generateSASToken function is a crucial part of our implementation. It creates a secure authentication token that Azure IoT Hub will recognize and accept. The function takes four inputs: hub name, device ID, device key, and an expiration duration.

The function works by creating a unique signature from the resource URI (combining hub name and device ID) and a timestamp. This signature is then hashed using HMAC-SHA256 with the device key. The resulting token allows our device to authenticate with Azure IoT Hub while ensuring the connection remains secure for the specified duration.

func generateSASToken(hubName, deviceID, deviceKey string, expiration time.Duration) string {
    // create the timestamp for expiration
    timestamp := time.Now().Add(expiration).Unix()
    timestampString := strconv.FormatInt(timestamp, 10)

    // create the resource uri
    uri := hubName + "/devices/" + deviceID
    escapedURI := url.QueryEscape(uri)

    // create the signature
    signature := escapedURI + "\n" + timestampString

    // hash the signature
    decodedKey, _ := base64.StdEncoding.DecodeString(deviceKey)
    hash := hmac.New(sha256.New, decodedKey)
    hash.Write([]byte(signature))
    encryptedSignature := hash.Sum(nil)
    decodedSignature := base64.StdEncoding.EncodeToString(encryptedSignature)
    escapedSignature := url.QueryEscape(decodedSignature)

    // create and return the token
    return "SharedAccessSignature sr=" + escapedURI + "&sig=" + escapedSignature + "&se=" + timestampString
}

Configuring and Creating the MQTT Client

In this configuration, we're establishing a secure connection to Azure IoT Hub using TLS over port 8883. The broker URL is formatted with the "ssl://" prefix to indicate secure communication. For authentication, Azure IoT Hub requires a specific username format combining the hub name and device ID with a slash separator (hubName + "/" + deviceID), while the SAS token we generated serves as the password. The TLS configuration is set to use the system's trusted certificates to verify Azure's server identity, with InsecureSkipVerify set to false to ensure proper certificate validation.

// create the client options
brokerURL := "ssl://" + hubName + ":8883"

username := hubName + "/" + deviceID

sasToken := generateSASToken(hubName, deviceID, deviceKey, tokenExpiration)

certPool, err := x509.SystemCertPool()
if err != nil {
    slog.Error("failed to load system certificate pool", "error", err)
    return
}

tlsConfig := &tls.Config{
    RootCAs:            certPool,
    MinVersion:         tls.VersionTLS12,
    InsecureSkipVerify: false,
    ServerName:         hubName,
}

opts := mqtt.NewClientOptions().
    AddBroker(brokerURL).
    SetClientID(deviceID).
    SetUsername(username).
    SetPassword(sasToken).
    SetTLSConfig(tlsConfig)

// create the client
client := mqtt.NewClient(opts)

Connecting to Azure IoT Hub

After configuring our client options, the next step is to establish the connection with Azure IoT Hub's MQTT broker. Here, we initiate the connection with client.Connect(), which returns a token that we can use to track the operation's status. The WaitTimeout() method blocks execution until the connection is established or the specified timeout is reached. We then check for any errors that might have occurred during the connection process. The defer statement ensures our client disconnects properly when the function exits, even if an error occurs later. Upon successful connection, we log a message to confirm we've connected to the broker.

// connect to the broker
token := client.Connect()
token.WaitTimeout(connectTimeout)
if err := token.Error(); err != nil {
    slog.Error("failed to connect", "error", err)
    return
}
defer client.Disconnect(disconnectTimeout)
slog.Info("connected")

Publishing Messages to Azure IoT Hub

Once connected, we can publish messages to Azure IoT Hub using the appropriate topic format. For device-to-cloud messaging, Azure IoT Hub expects messages on the topic devices/{deviceId}/messages/events/. The Publish method requires several parameters: the topic, Quality of Service (QoS) level, retain flag, and the message payload. For our example, we use QoS level 1, which ensures at-least-once delivery according to the MQTT specification (IBM documentation on QoS). The retain flag is set to true, indicating that the broker should keep the message for future subscribers. We use a simple "hello" string as our payload, which is converted to bytes before transmission. Similar to the connection process, we wait for the publish operation to complete or time out, and then check for any errors. A success message is logged when the message is successfully published to Azure IoT Hub.

// publish the message
topic := "devices/" + deviceID + "/messages/events/"
payload := "hello"
token = client.Publish(
    topic,           // topic
    1,               // qos
    true,            // retain
    []byte(payload), //payload
)
token.WaitTimeout(publishTimeout)
if err := token.Error(); err != nil {
    slog.Error("failed to publish", "error", err)
    return
}
slog.Info("message published")

Complete Implementation

Below is the complete Go code for connecting to Azure IoT Hub using MQTT with TLS security and SAS token authentication. This implementation includes all the components we've discussed: configuration, SAS token generation, client setup, connection establishment, and message publishing. Simply replace the placeholder values with your actual Azure IoT Hub information to get started.

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "crypto/tls"
    "crypto/x509"
    "encoding/base64"
    "log/slog"
    "net/url"
    "strconv"
    "time"

    mqtt "github.com/eclipse/paho.mqtt.golang"
)

// configuration
const (
    hubName         = "your-hub-name.azure-devices.net"
    deviceID        = "your-device-id"
    deviceKey       = "your-device-key"
    tokenExpiration = 60 * time.Minute
)

// timeouts
const (
    connectTimeout    = 5 * time.Second
    disconnectTimeout = 3000 // milliseconds
    publishTimeout    = 5 * time.Second
)

func main() {
    // create the client options
    brokerURL := "ssl://" + hubName + ":8883"
    username := hubName + "/" + deviceID
    sasToken := generateSASToken(hubName, deviceID, deviceKey, tokenExpiration)

    certPool, err := x509.SystemCertPool()
    if err != nil {
        slog.Error("failed to load system certificate pool", "error", err)
        return
    }

    tlsConfig := &tls.Config{
        RootCAs:            certPool,
        MinVersion:         tls.VersionTLS12,
        InsecureSkipVerify: false,
        ServerName:         hubName,
    }

    opts := mqtt.NewClientOptions().
        AddBroker(brokerURL).
        SetClientID(deviceID).
        SetUsername(username).
        SetPassword(sasToken).
        SetTLSConfig(tlsConfig)

    // create the client
    client := mqtt.NewClient(opts)

    // connect to the broker
    token := client.Connect()
    token.WaitTimeout(connectTimeout)
    if err := token.Error(); err != nil {
        slog.Error("failed to connect", "error", err)
        return
    }
    defer client.Disconnect(disconnectTimeout)
    slog.Info("connected")

    // publish the message
    topic := "devices/" + deviceID + "/messages/events/"
    payload := "hello"
    token = client.Publish(
        topic,           // topic
        1,               // qos
        true,            // retain
        []byte(payload), //payload
    )
    token.WaitTimeout(publishTimeout)
    if err := token.Error(); err != nil {
        slog.Error("failed to publish", "error", err)
        return
    }
    slog.Info("message published")
}

func generateSASToken(hubName, deviceID, key string, expiration time.Duration) string {
    // create the timestamp for expiration
    timestamp := time.Now().Add(expiration).Unix()
    timestampString := strconv.FormatInt(timestamp, 10)

    // create the resource uri
    uri := hubName + "/devices/" + deviceID
    escapedURI := url.QueryEscape(uri)

    // create the signature
    signature := escapedURI + "\n" + timestampString

    // hash the signature
    decodedKey, _ := base64.StdEncoding.DecodeString(key)
    hash := hmac.New(sha256.New, decodedKey)
    hash.Write([]byte(signature))
    encryptedSignature := hash.Sum(nil)
    decodedSignature := base64.StdEncoding.EncodeToString(encryptedSignature)
    escapedSignature := url.QueryEscape(decodedSignature)

    // create and return the token
    return "SharedAccessSignature sr=" + escapedURI + "&sig=" + escapedSignature + "&se=" + timestampString
}

Final Thoughts

This implementation focuses on the essentials of connecting to Azure IoT Hub via MQTT. I personally couldn't find any straightforward Go examples for this specific scenario online, which made creating this guide a priority.

The code covers the basics of authentication and message publishing, though there's room for improvement. For production use, you'd want to add proper connection event handlers, implement automatic SAS token renewal, and further customize the TLS configuration.

I hope this example provides a useful starting point for your IoT projects with Go and Azure. While simplified, it contains the key elements needed to establish secure communication with your IoT Hub.

Write Timeout

WriteTimeout is the maximum duration before timing out writes of the response.

To trigger a write timeout, we simulate a delay in the server's root handler. The client gets an io.EOF error when it tries to receive the response from the server.

server.go

package main

import (
    "fmt"
    "net/http"
    "time"
)

func main() {
    // create a new HTTP request multiplexer (router)
    h := http.NewServeMux()

    // register the root handler
    h.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
        // simulate a delay of 2 seconds to trigger a write timeout
        time.Sleep(2 * time.Second)

        // write the status
        w.WriteHeader(http.StatusOK)
    })

    // create the server with a write timeout of 1 second
    s := &http.Server{
        Addr:         ":8080",
        Handler:      h,
        WriteTimeout: 1 * time.Second,
    }

    // start the server
    fmt.Println("server: listening...")
    err := s.ListenAndServe()
    if err != nil && err != http.ErrServerClosed {
        fmt.Printf("server: %s\n", err.Error())
    }
}

client.go

package main

import (
    "fmt"
    "net/http"
    "os"
)

func main() {
    // try to send 
    resp, err := http.Get("http://localhost:8080/")
    if err != nil {
        fmt.Printf("client: %s\n", err)
        os.Exit(1)
    }
    defer resp.Body.Close()
    fmt.Printf("client: %s\n", resp.Status)
}

Client Output:

client: Get "http://localhost:8080/": EOF
exit status 1

Idle Timeout

IdleTimeout is the maximum amount of time to wait for the next request when keep-alives are enabled.

To trigger an idle timeout, we simulate a delay in the client after sending the first request and reading the status of the first response from the server. The client gets an io.EOF error when it tries to read the status of the second response.

server.go

package main

import (
    "fmt"
    "net/http"
    "time"
)

func main() {
    // create a new HTTP request multiplexer (router)
    h := http.NewServeMux()

    // register the root handler
    h.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
        // write the status
        w.WriteHeader(http.StatusOK)
    })

    // create the server with an idle timeout of 1 second
    s := &http.Server{
        Addr:        ":8080",
        Handler:     h,
        IdleTimeout: 1 * time.Second,
    }

    // start the server
    fmt.Println("server: listening...")
    err := s.ListenAndServe()
    if err != nil && err != http.ErrServerClosed {
        fmt.Printf("server: %s\n", err.Error())
    }
}

client.go

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "time"
)

func main() {
    // connect to the server
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        fmt.Printf("client: %s\n", err.Error())
        os.Exit(1)
    }

    // write the first request
    fmt.Fprintf(conn, "GET / HTTP/1.1\r\n")
    fmt.Fprintf(conn, "Host: localhost:8080\r\n")
    fmt.Fprintf(conn, "Connection: keep-alive\r\n")
    fmt.Fprintf(conn, "\r\n")

    // read the status of the first response
    reader := bufio.NewReader(conn)
    status, err := reader.ReadString('\n')
    if err != nil {
        fmt.Printf("client: %s\n", err.Error())
        os.Exit(1)
    }
    fmt.Printf("client: %s", status)

    // discard the rest of the first response
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            fmt.Println("client: ", err.Error())
            os.Exit(1)
        }
        if line == "\r\n" {
            break
        }
    }

    // simulate a delay of 2 seconds to trigger an idle timeout
    time.Sleep(2 * time.Second)

    // write the second request
    fmt.Fprintf(conn, "GET / HTTP/1.1\r\n")
    fmt.Fprintf(conn, "Host: localhost:8080\r\n")
    fmt.Fprintf(conn, "Connection: keep-alive\r\n")
    fmt.Fprintf(conn, "\r\n")

    // try to read the status of the second response
    status, err = reader.ReadString('\n')
    if err != nil {
        fmt.Printf("client: %s\n", err.Error())
        os.Exit(1)
    }
    fmt.Printf("client: %s", status)
}

Client Output

client: HTTP/1.1 200 OK
client: EOF
exit status 1

Read Timeout

ReadTimeout is the maximum duration for reading the entire request, including the body.

To trigger a read timeout, we simulate a delay in the client after it connects to the server. The client gets an io.EOF error when it tries to read the server's response status.

server.go

package main

import (
    "fmt"
    "net/http"
    "time"
)

func main() {
    // create a new HTTP request multiplexer (router)
    h := http.NewServeMux()

    // register the root handler
    h.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
        // write the status
        w.WriteHeader(http.StatusOK)
    })

    // create the server with a read timeout of 1 second
    s := &http.Server{
        Addr:        ":8080",
        Handler:     h,
        ReadTimeout: 1 * time.Second,
    }

    // start the server
    fmt.Println("server: listening...")
    err := s.ListenAndServe()
    if err != nil && err != http.ErrServerClosed {
        fmt.Printf("server: %s\n", err.Error())
    }
}

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "time"
)

func main() {
    // connect to the server
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        fmt.Printf("client: %s\n", err.Error())
        os.Exit(1)
    }

    // simulate a delay of 2 seconds to trigger a read timeout
    time.Sleep(2 * time.Second)

    // write the first request
    fmt.Fprintf(conn, "GET / HTTP/1.1\r\n")
    fmt.Fprintf(conn, "Host: localhost:8080\r\n")
    fmt.Fprintf(conn, "Connection: keep-alive\r\n")
    fmt.Fprintf(conn, "\r\n")

    // read the status of the first response
    reader := bufio.NewReader(conn)
    status, err := reader.ReadString('\n')
    if err != nil {
        fmt.Printf("client: %s\n", err.Error())
        os.Exit(1)
    }
    fmt.Printf("client: %s", status)
}

Client Output

client: EOF
exit status 1

We can implement a simple key-value store that is concurrently safe by using a mutex. However, using a single mutex creates a bottleneck, as all concurrent requests will have to wait for the mutex to be released before they can proceed.

package store

import "sync"

type Store interface {
    Get(key string) ([]byte, bool)
    Set(key string, value []byte)
}

type store struct {
    mu    *sync.RWMutex
    items map[string][]byte
}

func NewStore() Store {
    return &store{
        mu:    &sync.RWMutex{},
        items: make(map[string][]byte),
    }
}

func (s *store) Get(key string) ([]byte, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    value, ok := s.items[key]
    return value, ok
}

func (s *store) Set(key string, value []byte) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.items[key] = value
}

We can write an integration test to set and get one million records concurrently.

package store

import (
    "fmt"
    "reflect"
    "testing"
)

func TestIntegration(t *testing.T) {
    s := NewStore()
    goroutines := 1024
    count := 1_000_000
    sem := make(chan struct{}, goroutines)

    // concurrent sets
    for i := 0; i < count; i++ {
        sem <- struct{}{}
        go func(j int) {
            defer func() {
                <-sem
            }()
            key, value := makeKeyValuePair(j)
            s.Set(key, value)
        }(i)
    }
    for i := 0; i < goroutines; i++ {
        sem <- struct{}{}
    }

    // concurrent gets
    for i := 0; i < count; i++ {
        <-sem
        go func(j int) {
            defer func() {
                sem <- struct{}{}
            }()
            key, expected := makeKeyValuePair(j)
            actual, ok := s.Get(key)
            if !ok {
                t.Errorf("key doesn't exist: '%s'", key)
            }
            if !reflect.DeepEqual(expected, actual) {
                t.Errorf("expected doesn't match actual, expected: '%s' actual: '%s'", expected, actual)
            }
        }(i)
    }
    for i := 0; i < goroutines; i++ {
        <-sem
    }
}

func makeKeyValuePair(i int) (string, []byte) {
    key := fmt.Sprintf("%d", i)
    value := []byte(fmt.Sprintf("%d", i))
    return key, value
}

This test is completed in 2.23 seconds on my machine.

To solve the bottleneck caused by the single mutex, we can divide the data into shards, each with its own mutex. This reduces contention for the mutex, which can improve throughput and latency.

A shard is essentially a smaller key-value store that can be accessed independently.

package store

import (
    "crypto/md5"
    "encoding/hex"
    "sync"
)

const defaultShardKeyLength = 2 // default shard count: 16^2

type shard struct {
    mu    *sync.RWMutex
    items map[string][]byte
}

func makeShardKey(key string) string {
    h := md5.New()
    h.Write([]byte(key))
    sum := h.Sum(nil)
    encoded := hex.EncodeToString(sum)
    return encoded[:defaultShardKeyLength]
}

func newShard() *shard {
    return &shard{
        mu:    &sync.RWMutex{},
        items: make(map[string][]byte),
    }
}

func (s *shard) get(key string) ([]byte, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    v, ok := s.items[key]
    return v, ok
}

func (s *shard) set(key string, value []byte) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.items[key] = value
}

We can modify our code to implement sharding.

package store

import "sync"

type Store interface {
    Get(key string) ([]byte, bool)
    Set(key string, value []byte)
}

type store struct {
    mu     *sync.RWMutex
    shards map[string]*shard
}

func NewStore() Store {
    return &store{
        mu:     &sync.RWMutex{},
        shards: make(map[string]*shard),
    }
}

func (s *store) Get(key string) ([]byte, bool) {
    shardKey := makeShardKey(key)
    s.mu.RLock()
    shard, ok := s.shards[shardKey]
    if !ok {
        return nil, false
    }
    s.mu.RUnlock()

    return shard.get(key)
}

func (s *store) Set(key string, value []byte) {
    shardKey := makeShardKey(key)
    s.mu.Lock()
    shard, ok := s.shards[shardKey]
    if !ok {
        shard = newShard()
        s.shards[shardKey] = shard
    }
    s.mu.Unlock()

    shard.set(key, value)
}

If we run the integration test, it completes in 1.78 seconds, which is roughly 20% faster than the simple key-value store. This suggests that sharding has improved performance under the conditions of this test.

In conclusion, sharding can be a useful technique for improving the performance of a key-value store.

Thank you for reading my article. I hope that you found it helpful. If you have any questions or feedback, please feel free to leave a comment below.

def fun(...) do
    ...
    fun(...)
end

Elixir optimizes tail calls by reusing the last stack frame of the function, thus avoiding the typical stack push and reducing the overhead of creating and removing stack frames during function calls.

This function calculates the nth Fibonacci sequence element.

defmodule Fibonacci do
  def nth(n) when n <= 1, do: n

  def nth(n) do
    nth(n - 1) + nth(n - 2)
  end
end

This function is not tail-recursive, as the tail call involves the summation of two functions.

This is (my) tail recursive version of the same function:

defmodule Fibonacci do
  def nth(n) when n <= 1, do: n

  def nth(n) do
    fib(n - 2, 1, 0)
  end

  defp fib(0, minus_1, minus_2) do
    minus_1 + minus_2
  end

  defp fib(n, minus_1, minus_2) do
    fib(n - 1, minus_1 + minus_2, minus_1)
  end
end

This function is tail-recursive, as the tail call directly invokes the function itself.

Let's compare the execution duration of the two functions with the following code one by one.

start_time = :os.system_time(:native)
result = Fibonacci.nth(20)
end_time = :os.system_time(:native)
duration = end_time - start_time
IO.puts("result: #{result} duration: #{duration} nanoseconds")

Output of the first version:

result: 6765 duration: 60000 nanoseconds

Output of the optimized version:

result: 6765 duration: 1000 nanoseconds

The tail-call optimization significantly improved the execution time.

Thanks for reading!