https://jbrandhorst.com/post/ Recent content in Posts on Go Ahead Hugo -- 0.126.1 en Thu, 20 Oct 2022 00:00:00 +0000 https://jbrandhorst.com/post/plugin-versioning/ Thu, 20 Oct 2022 00:00:00 +0000 https://jbrandhorst.com/post/plugin-versioning/ Update on Go 1.24 tool dependencies Go 1.24 introduced the -tool flag to go get and the tool stanza to go.mod. This makes tool dependencies an excellent way to manage protobuf plugins. I have rewritten this post with that in mind. Background When working with Protobuf and gRPC, one of the first things that you as a user has to figure out is how to generate code from your Protobuf definitions. https://jbrandhorst.com/post/serverless-application-stack/ Sat, 20 Nov 2021 00:00:00 +0000 https://jbrandhorst.com/post/serverless-application-stack/ The dream of a serverless, general-purpose, portable application stack is finally a reality. TL;DR: deploy your application to GCP Cloud Run with a CockroachDB Serverless instance for persistence. Read on for a deeper dive. Serverless compute AWS Lambda revolutionized the industry by introducing the concept of “serverless” computing to the masses. Today it lets devs and companies alike pay for exactly the amount of compute they need, down to the millisecond it takes to execute the code. https://jbrandhorst.com/post/grpc-in-the-browser/ Sun, 24 Oct 2021 00:00:00 +0000 https://jbrandhorst.com/post/grpc-in-the-browser/ Ever since I first started using gRPC in 2016, I’ve been interested in learning how to use it well with browser clients. It’s a common question to ask once you’ve decided that you are going to use gRPC for service-to-service and mobile app communication. Here’s this great technology that abstracts away the problems I was having when making RPC calls between my services. How do I use it for my front-end applications? https://jbrandhorst.com/post/postgres/ Sun, 07 Apr 2019 00:00:00 +0000 https://jbrandhorst.com/post/postgres/ Most developers will have to interact with SQL at some point in their career, and often nowadays that means working with Postgres. I’ve been using Postgres with Go for a few years now and have found a couple of libraries that work really well together to make the Go Postgres experience productive, safe and fun. TL:DR; I have created an example repo that puts all of the below into practice: github. https://jbrandhorst.com/post/state-of-grpcweb/ Tue, 08 Jan 2019 00:00:00 +0000 https://jbrandhorst.com/post/state-of-grpcweb/ gRPC 1.0 was released in August 2016 and has since grown to become one of the premier technical solutions for application communications. It has been adopted by startups, enterprise companies, and open source projects worldwide. Its support for polyglot environments, focus on performance, type safety, and developer productivity has transformed the way developers design their architectures. So far the benefits have largely only been available to mobile app and backend developers, whilst frontend developers have had to continue to rely on JSON REST interfaces as their primary means of information exchange. https://jbrandhorst.com/post/grpc-auth/ Sun, 22 Jul 2018 00:00:00 +0000 https://jbrandhorst.com/post/grpc-auth/ Introduction Best practices for performing client authentication with gRPC is a question that comes up again and again, so I thought I’d dive into a few different methods for performing authentication, using the tools provided by the Go gRPC packages. Today we’ll explore 3 methods of authentication: TLS Client certificate authentication Token Header authentication HTTP Basic authentication For the TL:DR; check the example repo. Note: Go-gRPC interceptors are being redesigned, so if you implement this in your server today, you may want to keep in mind that it will change again in the future. https://jbrandhorst.com/post/grpc-json/ Sat, 21 Jul 2018 00:00:00 +0000 https://jbrandhorst.com/post/grpc-json/ Introduction It’s often said that gRPC is tied to the Google Protocol Buffers payload format, but this is not strictly true. While the default format for gRPC payloads is Protobuf, the gRPC-Go implementation exposes a Codec interface which allows arbitrary payload encoding. This could be used for all kinds of things, like your own binary format, using flatbuffers, or, as we shall see today, using JSON for requests and responses. https://jbrandhorst.com/post/redeploy/ Tue, 24 Apr 2018 00:00:00 +0000 https://jbrandhorst.com/post/redeploy/ Introduction Last year I wrote a post about automating deployment of your application, all the way from git push to redeploying your application in your environment. It relied on the free version of Docker Cloud, which allowed the use of a single node for free. Of course, the idea was that you should eventually want to scale your deployment, and then you’d need to pay. As long as all you needed was a single node, Docker Cloud and its Bring Your Own Host was powerful, flexible and simple. https://jbrandhorst.com/post/certify/ Sun, 25 Mar 2018 00:00:00 +0000 https://jbrandhorst.com/post/certify/ It’s often recommended that microservice communications are encrypted, especially if they cross the public internet. Even when you control the network, whether virtually or physically, encrypting traffic can still be valuable. Lets Encrypt has revolutionized the distribution of certificates for publically facing servers; unfortunately, encrypting internal traffic often involves complicated certificate generation setups. Hashicorp Vault is a project for storing secrets and performing authentication. It has a PKI Secret Engine backend which allows you to use it as a certificate authority in an internal public key infrastructure deployment. https://jbrandhorst.com/post/grpc-errors/ Mon, 19 Mar 2018 00:00:00 +0000 https://jbrandhorst.com/post/grpc-errors/ How to best handle errors in Go is a divisive issue, leading to opinion pieces by illustrious bloggers such as Dave Cheney, the commander himself Rob Pike as well as the official Go blog. I’m not going to tackle those opinions here, instead I’m going to talk about best practices for errors when using gRPC and Go. The gRPC Status package The Go gRPC implementation has a status package which exposes a nice simple interface for creating rich gRPC errors. https://jbrandhorst.com/post/gogoproto/ Mon, 19 Feb 2018 00:00:00 +0000 https://jbrandhorst.com/post/gogoproto/ Introduction In the Go protobuf ecosystem there are two major implementations to choose from. There’s the official golang/protobuf, which uses reflection to marshal and unmarshal structs, and there’s gogo/protobuf, a third party implementation that leverages type-specific marshalling code for extra performance, and has many cool extensions you can use to customize the generated code. gogo/protobuf has been recommended as the best choice of Go serialization library in a large test of different implementations. https://jbrandhorst.com/post/budapest/ Sat, 10 Feb 2018 00:00:00 +0000 https://jbrandhorst.com/post/budapest/ Introduction After my presentation at the Go London meetup I was approached on Gophers slack by a gentleman from Hungary called Máté Gulyás. Máté is one of the organisers of the Budapest Go Meetup, and was reaching out to me to ask if I would like to come down to Budapest and deliver a talk for the meetup. I was delighted with this invitation and promptly accepted and we started planning. https://jbrandhorst.com/post/client-streaming/ Sun, 17 Sep 2017 00:00:00 +0000 https://jbrandhorst.com/post/client-streaming/ In a previous post I introduced my open source project to bring GopherJS bindings to Improbable’s gRPC-Web client. I’m happy to say that the initial goal of supporting all features of the gRPC-Web client has been completed. I was initially going to leave it at that and wait for client side streaming to land in the WHATWG Streams API Standard, and subsequently added to the official grpc-web spec and probably the gRPC-Web client, but then I was sitting at the GolangUK conference and I had a brain wave. https://jbrandhorst.com/post/circleci-docker-compose/ Fri, 04 Aug 2017 00:00:00 +0000 https://jbrandhorst.com/post/circleci-docker-compose/ In a recent blog post I talked about automating the testing of an advanced GopherJS library using a combination of QUnit, Ginkgo and Agouti. That allowed me to run a complete integration test suite against my library by automatically spinning up browsers and pointing them at my QUnit GopherJS page. This was a great start, but after running it a couple of times we find that there are several problems: https://jbrandhorst.com/post/grpc-binary-blob-stream/ Fri, 14 Jul 2017 00:00:00 +0000 https://jbrandhorst.com/post/grpc-binary-blob-stream/ One of the gotchas of using gRPC is that it was not designed to transport large messages in one chunk. The default max message size is slightly arbitrarily set at 4MB today, and while it is possible to configure, that kind of behaviour might lead to a slippery slope scenario of ever increasing max message sizes. So what do we do when the message size is too large? We chunk the data into smaller pieces and stream it, using the gRPC streaming methods, naturally. https://jbrandhorst.com/post/go-semaphore/ Fri, 14 Jul 2017 00:00:00 +0000 https://jbrandhorst.com/post/go-semaphore/ Sometimes when you’re writing a server, you’ve got a function that consumes a lot of memory while running, or some other resource, and you might be worrying that a sudden burst of requests could crash the server, since gRPC by default will just spawn another goroutine to handle any incoming requests, oblivious to the danger. In these situations, it can be useful to implement some custom request throttling. Here I’ll show an easy way to accomplish this with the use of a Go channel. https://jbrandhorst.com/post/gopherjs-integration-tests/ Tue, 11 Jul 2017 00:00:00 +0000 https://jbrandhorst.com/post/gopherjs-integration-tests/ Recently I found myself wondering how I was going to test my new GopherJS gRPC-Web bindings. Writing tests was something I had been waiting with until I had something working, mostly because I had no idea how I was going to meaningfully test GopherJS code that relies on interactions with JS and the reponses of a server. I have in the past made a small contribution to the GopherJS websocket repo, and found myself impressed with the extensive tests written for the repo. https://jbrandhorst.com/post/gopherjs-grpcweb/ Tue, 20 Jun 2017 00:00:00 +0000 https://jbrandhorst.com/post/gopherjs-grpcweb/ In a previous blog series I’ve talked about how to work with a gRPC backend from the GopherJS world. It relies on the gRPC-gateway which is a great piece of tech, but unfortunately carries a couple of downsides: Clients don’t know what types are used - the interface is HTTP JSON. This can be somewhat mitigated with the use of swagger generated interfaces, but it’s still not perfect. The interface being JSON means marshalling and unmarshalling can become a significant part of the latency between the client and the server. https://jbrandhorst.com/post/app-deployment/ Sun, 04 Jun 2017 00:00:00 +0000 https://jbrandhorst.com/post/app-deployment/ Update Docker Cloud is being discontinued. For an alternative easy app deployment, check my new post on automatic app deployment. Furthermore, I would nowadays recommend Hetzner Cloud over Scaleway. Scaleway was running out of instances last time I tried using them, and Hetzner’s web console is much better than Scaleways. Old post preserved below. Introduction Yesterday (!) I asked in the Gophers slack for recommendations for deployment of static Go binaries, as I was in the process of deploying a demo for another blog post I’m working on. https://jbrandhorst.com/post/go-protobuf-tips/ Tue, 18 Apr 2017 00:00:00 +0000 https://jbrandhorst.com/post/go-protobuf-tips/ I’ve had my fair share of dealing with proto files in go (and to some extent JS), so I thought I’d share some stuff I’ve learnt the hard way by working with proto files. Protoc include paths The protoc include paths can be pretty confusing, so I’ll give a few examples of how to use it properly. Just include the current directory protoc requires that the files referenced are in the include path, so if you’re referencing files relative to the current directory, you’ll need to specify -I. https://jbrandhorst.com/post/gopherjs-client-grpc-server-4/ Fri, 14 Apr 2017 00:00:00 +0000 https://jbrandhorst.com/post/gopherjs-client-grpc-server-4/ Putting it all together As we touched upon earlier, we generate a package from the generated JS (meta, right?), which can be served from the server. We’ll create a new file, main.go, in which we can spin up a server, serve the frontend and the gRPC backend. Much of the logic in this file is inspired by the excellent blog post put together by Brandon Philips over at CoreOS. We’re using his elegant solution to serve both the HTTP API and the gRPC API on the same port. https://jbrandhorst.com/post/gopherjs-client-grpc-server-3/ Thu, 13 Apr 2017 00:00:00 +0000 https://jbrandhorst.com/post/gopherjs-client-grpc-server-3/ Implement the client GopherJS can be used in a couple of different ways, and there’s a couple of different bindings to many popular JavaScript frameworks. The GopherJS wiki has some great resources. I tried a couple of different ones and ended up using the VueJS bindings because it made it easy to prototype things quickly. I hear VueJS works well for many JS evangelisers out there, but I’ve only used it with small projects. https://jbrandhorst.com/post/gopherjs-client-grpc-server-2/ Wed, 12 Apr 2017 00:00:00 +0000 https://jbrandhorst.com/post/gopherjs-client-grpc-server-2/ Implement the server I like to start by creating a struct and write a simple definition that’ll immediately fail to compile. package server import ( "github.com/johanbrandhorst/gopherjs-grpc-websocket/protos/server" ) type Server struct{} var _ server.MyServerServer = &Server{} This won’t compile, because the Server struct does not implement the server.MyServerServer interface. But it’ll also tell us what we’ve got left to implement. So lets implement the server methods: func (s Server) Simple(ctx context.Context, _ *empty. https://jbrandhorst.com/post/gopherjs-client-grpc-server-1/ Tue, 11 Apr 2017 00:00:00 +0000 https://jbrandhorst.com/post/gopherjs-client-grpc-server-1/ Create the protobuf interface We’ll start by creating a folder for the package we want to create. Lets call it server. Next we type up a .proto file to define the interface between the server and the client. We’ll have to include some extra proto annotations in order to have the gRPC-gateway generate the translations methods we need. Lets define a simple service with a single HTTP GET endpoint: service MyServer { rpc Simple(google. https://jbrandhorst.com/post/gopherjs-client-grpc-server/ Mon, 10 Apr 2017 00:00:00 +0000 https://jbrandhorst.com/post/gopherjs-client-grpc-server/ I’ve been using gRPC and Go a lot in the last year. At Cognitive Logic every one of our backend services is implemented with Go and gRPC, and it enables us to abstract away most of the complexities of networked micro services and keep interfaces typed and well defined using Google protobuffers. I really enjoy using both, but sometimes I need to write a frontend to a web server and I despise writing Javascript.