In Golang, it is common to see errors return as:

errors.New(msg)

And:

fmt.Error(msg)
fmt.Errorf("...",msg,foo,bar)

If there are nested errors, these can be wrapped into a new error using the %w formatting directive:

if err!=nil {
    msg := "something went wrong"
    return ...,fmt.Errorf("%s: %w", msg, err)
}

It is good practice to create custom error types.

Not only can this improve readability but it enables a mechanism where the error type can be used to clarify code.

I’m spending some time trying to better understand best practices for Golang Modules and when used with GitHub’s Dependabot.

One practice I’m pursuing is to not (GitHub) Release Go Modules in separate repos that form part of a single application. In my scenario, I chose to not use a monorepo and so I have an application smeared across multiple repos. See GitHub help with dependency management

If a Module is not Released (on GithUb) then the go tooling versions the repo as:

A smörgåsbord of guidance involving Golang modules, private repos and containers. Everything herein is documented elsewhere (I’ll provide links) but I wanted to consolidate the information primarily for my own benefit.

GOPRIVATE

Using private modules adds complexity because builders need to be able to access private modules. Customarily, as you’re hacking away, you’ll likely not encounter issues but, when you write a Dockerfile or develop some CI, you’ll encounter something of the form:

I’ve been spending some time learning Akri.

One proposal was to develop a webhook handler to check the YAML of Akri’s Configurations (CRDs). Configurations are used to describe Akri Brokers. They combine a Protocol reference (e.g. zeroconf) with a Kubernetes PodSpec (one of more containers), one of which references(using .resources.limits.{{PLACEHOLDER}}) the Akri device to be bound to the broker.

In order to validate the Configuration, one of Akri’s developers proposed using JSONPAth as a way to ‘query’ Kubernetes configuration files. This is a clever suggestion.

Golang

Go provides an implementation gprc_health_v1 of the gRPC Health-checking Protocol proto.

This is easily implemented:

package main

import (

	pb "github.com/DazWilkin/.../protos"

	"google.golang.org/grpc"
	"google.golang.org/grpc/health"
	healthpb "google.golang.org/grpc/health/grpc_health_v1"
)


func main() {
	...

	serverOpts := []grpc.ServerOption{}
	grpcServer := grpc.NewServer(serverOpts...)

	// Register the pb service
	pb.RegisterSomeServer(grpcServer, NewServer())

	// Register the healthpb service
	healthpb.RegisterHealthServer(grpcServer, health.NewServer())

	listen, err := net.Listen("tcp", *grpcEndpoint)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("[main] Starting gRPC Listener [%s]\n", *grpcEndpoint)
	log.Fatal(grpcServer.Serve(listen))
}

Because it’s gRPC, you need an implementation of the proto for the client, one is provided too grpc-health-probe: