Golang on Experiment, Fail, Learn, Repeat

Adding SSO to MCP Grafana Server

Mon, 25 May 2026 00:00:00 +0000

The MCP Grafana server previously relied on static API keys or basic auth for authenticating requests to Grafana. This works fine for local development or single-user setups, but falls apart once you have multiple users who each need their own Grafana permissions. Passing around shared API keys is a security concern and means everyone operates with the same access level regardless of their actual role.

Building a code assessment tool but in Kubernetes

Sun, 10 Nov 2024 00:00:00 +0000

I had previously attempted to build a code assessment tool in docker. That involves doing the following:

Nginx as API Gateway - focusing on auth_request directive

Wed, 01 Nov 2023 00:00:00 +0000

On virtual machine How to “protect” api requests https://www.nginx.com/blog/deploying-nginx-plus-as-an-api-gateway-part-1/

Mostly is the auth_request directive

Microservices are a software architectural style that structures an application as a collection of loosely coupled, independently deployable services. Each service in a microservices architecture represents a specific business capability and communicates with other services through well-defined APIs (Application Programming Interfaces). These services are designed to be small, focused, and can be developed, deployed, and scaled independently. Its a somewhat common architectural pattern that many companies go to when it comes to scaling out their development teams to build out their product.

Access Cloud SQL from Google Cloud Run without Serverless VPC Access Connectors but via VPC

Wed, 11 Oct 2023 00:00:00 +0000

Introduction
#

Previously, Serverless VPC Access connector is a commonly used solution to connect Cloud Run to Cloud SQL securely. This option is still available for use today but with all the previous blog posts that cover how we can:

Multiple Database Support - MySQL and SQLite support

Wed, 04 Oct 2023 00:00:00 +0000

I intend to try out the Turso service in order to see if there is any other potential serverless database that would have pretty decent type of billing for small projects. There isn’t a proper SQL based database that can be billed in a similar way to the Cloud Run product - it’ll be great if the billing of the database product would be along the amount of data being stored or amount of read/write requests done for the data instead of the usual charged based on how long the instance being run (based on how Cloud SQL is billed).

Serverless Applications with Cloud Run with Serverless MySQL from PlanetScale

Wed, 27 Sep 2023 00:00:00 +0000

Serverless computing, as seen in platforms like Cloud Run or AWS Lambda, allows developers to run code without managing the underlying infrastructure. This is achieved by automatically scaling the resources based on the incoming requests, and users are billed based on the actual execution time and resources consumed during each function or container invocation.

Access Cloud SQL from Google Kubernetes Cluster without Cloud SQL Proxy

Wed, 20 Sep 2023 00:00:00 +0000

Introduction
#

Similar to my previous blog post, we would usually be connecting Google Kubernetes Engine (GKE) clusters to Cloud SQL databases by using the Cloud SQL Proxy. However, we can now use Private Service Connect, which allows for private communication between different Google Cloud services, similar to how we did for connecting our application in Google Compute Engine (VM) to a Cloud SQL instance.

Access Cloud SQL from Google Compute Engine without Cloud SQL Proxy

Wed, 13 Sep 2023 00:00:00 +0000

Traditionally, when connecting a Google Compute Engine instance to a Cloud SQL database, the Cloud SQL Proxy was commonly used to facilitate secure connections. The Cloud SQL Proxy acted as an intermediary between the application running on a Compute Engine instance and the Cloud SQL database. It helped to secure the connection by using the Cloud SQL IAM database authentication and provided a way to connect to the database using a Unix socket.

Storing Helm in Docker Registries

Wed, 23 Aug 2023 00:00:00 +0000

We can apparently now store helm charts in Docker registries - this was made available via helm commands since v3.8.0. https://helm.sh/docs/topics/registries/

Now with that being available for use, we can now use it across a variety of storage mechanism (as compared in the past when the artifacts produced through it has to be managed in some of file system and would require some of index file to list all available helm charts available).

Python call Golang functions via Wasm/Wasi

Wed, 16 Aug 2023 00:00:00 +0000

Inspirations
#

While I was watching the following video of a talk by Richard Feldman: https://www.youtube.com/watch?v=zX-kazAtX0c&ab_channel=ChariotSolutions. He was covering a pretty interesting concept/topic of how would one “slowly” migrate codebases from one language to another. Let’s say the codebase for an application is pretty large - how would we safely move it over and change it without increasing the deployment targets? Let’s say we’re not in microservices land and it is difficult for us to do the whole deployment for a whole other server just to begin the migration of languages.

Writing code to store items in memory with Golang but with maps

Wed, 09 Aug 2023 00:00:00 +0000

The following blog post is a continuation of the previous blog post on Writing code to store items in memory with Golang. The previous blog post was mostly to cover simpler cases where we storing something simple like data in a single array/slice. However, let’s say if we were to expand our use case to store in some sort of map instead (I know there is a concurrent hashmap version but let’s pretend it doesn’t exist here). How shall we build a store which uses hashmap to store key value pairs.

Writing code to store items in memory with Golang

Wed, 02 Aug 2023 00:00:00 +0000

I have a small tiny application that is a http api server that is meant to store data temporarily in memory. There is no need to persist data into any file or even database. The data that is to be stored doesn’t need to persist across restarts - hence, making it nonsensical to rely on files or databases.

Using Emulators for testing Google Cloud Datastore integration

Wed, 26 Jul 2023 00:00:00 +0000

Motivation for finding emulator for Google Cloud Datastore
#

Many applications out there in the real world would require the use of databases to persist data. In the cases where an application depends on databases such as mysql or mariadb or postresql, we can create some form of “staging” server where we can test that the application works as expected. Additionally, we can even test to make sure that any database migration works as well without too much issues - we can import in some of the data from production and import it into the staging environment to make sure that it works.

Heap datastructure with Slices/Arrays in Golang

Wed, 19 Jul 2023 00:00:00 +0000

Part of the software engineer journey is to learn data structures - especially if one were to go for the software interviews. Surprising, data structures knowledge and familiarity with it becomes somewhat important in them - with knowledge with certain data strucutre, certain problems become somewhat easier (also, sometimes, all one can do is simply stare in wonder at the algorithms and data structures that people in the past created)

Deploy Golang Apps that interact with headless service in Kubernetes

Wed, 12 Jul 2023 00:00:00 +0000

In certain application scenarios - there is a need to have applications that need to do client side load balancing to a bunch of servers. Such cases are pretty rare - but we won’t be covering the exect reasons or scenarios or when these are needed. Instead, we will cover how we can do so with Golang applications in Kubernetes cluster.

Redis vs Memcached via Golang

Wed, 05 Jul 2023 00:00:00 +0000

This is often a question that often comes up during system design interviews. If one were to design a system that requires the use of cache - one common question that comes up would be whether to use memcached or to use redis. On initial thought - both are kind of doing the same thing; both store stuff in memory which gives them pretty fast response times; however, both tools have entirely wildly different implementations and philosophies when it comes to the product - thereby - requiring developers to make tradeoffs when choosing between them.

Trying to create MariaDB replica server

Wed, 28 Jun 2023 00:00:00 +0000

A common architectural pattern for relational databases is to create an additional replica server. This pattern usually come up due because most applications are usually read heavy - data is usually read to be presented to users.

Replicating golang interfaces with static python, run with mypy

Wed, 21 Jun 2023 00:00:00 +0000

After coding in both Python and Golang, I now have a very strong preference for strongly typed languages. There is a certain charm and beauty in being able to have the IDE that I’m working in able to provide good autocomplete suggestions for the code - there is less for a need to keep moving files in the codebases just to ensure that the function spelling and params are correct etc. For smaller programs, dynamic types languages are still ok but they get very unwieldy once they go pass the hundreds of lines of code mark.

Running database migrations in Helm chart

Wed, 07 Jun 2023 00:00:00 +0000

In many examples for helm charts, the general focus is on the “2nd” day operations of having applications running without too much issues. In the case for usual web developers, that would mean applications handled with kubernetes deployment objects which would run a set number of replicas (or handled via HPA) in the kubernetes cluster.

Using smaller base images for applications, slim images? alpine images? distroless images

Wed, 31 May 2023 00:00:00 +0000

When building applications in docker images, there is sometimes a need to consider the size of the containers. There are multiple reasons for us to monitor and check this:

In the case where our container registry is actually by us rather than the on public registries. The size of the container would affect the cost of storing all those artifacts. Let’s say we are to look at some of the private container registries that we can setup on public clouds such as Google Cloud - there is a pricing set on per GB of storage as well as networking costs for shifting the container images out of the container registry.
A smaller image is simply faster to move around. Let’s say if we have a Kubernetes cluster that would need to run the container and let’s also say that we need the container be run on multiple nodes of the cluster. Evidently, a container with a smaller footprint will take a way shorter time to pull the images from the registry. A larger container that could easily be in the Gigabyte range - e.g. images that container language runtimes etc. would take a way longer time to download as well as startup.
One can kind of argue that the less stuff inside the container, the smaller the container would contain an application that has a security loophole.

With that, it is beneficial for us to build “smaller” container images - the benefits would be more evident more so for the infrastructure teams rather than the application teams. To application teams, we would probably have to suffer quite a bit since smaller container images would mean “useful” stuff would be removed from the container.

Altering outputs of helm installations with post-renderer via kustomize

Wed, 24 May 2023 00:00:00 +0000

When one thinks of Kubernetes and deploying stuff into Kubernetes, one of the usual ways to get such stuff into Kubernetes is through the use of Kubernetes manifest files. Kubernetes manifest files describe various different resources in Kubernetes cluster - some primary examples that are often used are Deployment, Configmap, Secret, Service and even Ingress Kubernetes resources/objects.

Updating configuration in Kubernetes pods managed via Helm

Wed, 17 May 2023 00:00:00 +0000

When building an application, a common way to alter and set the running properties of the application is to use configuration files that could be written with JSON or Yaml files. This is the same even if the application is simply deployed in a Virtual Machine or even in a container within a Kubernetes Cluster. The general assumption is that the configuration file does not change that often - if the configuration files is to be change, the usual way to have the application conform to the new configuration file would be stop the currently running the application and start it once more.

Consistent Hashing Implementation in Golang

Wed, 10 May 2023 00:00:00 +0000

In the real world, we often have to deal with such large traffic loads that it is almost necessary to know that there is possibility that we might need to get data stored in a cluster of machines. In the case if we have applications that barely need to deal and manage data, we can simply on existing products out there that can simply scale out the number of replicas of the application which it can simply serve pretty easily. However, what about applications that rely on database? We need our database server cluster to also scale out accordingly as well (there are limits to scale vertically in most cloud providers after all)

Rethinking migrations in Golang Applications

Wed, 03 May 2023 00:00:00 +0000

This is more of a reminder post for me that every aspect of application development is critical and sufficient thought should be put behind it. This time around, it’s on database migration within applications.

Writing Rego Policies for authorization in Golang Apps

Wed, 26 Apr 2023 00:00:00 +0000

When building login systems in applications, there are generally two parts to it; authentication and authorization. Authentication is the step to provide and identify who the user that is attempting to use the system. Authorization is the step to decide whether user that is using the system is “allowed” to access or modify a particular resource on a system.

Serving Videos with Golang via HLS

Wed, 05 Apr 2023 00:00:00 +0000

I was watching a bunch of tiktok and youtube videos recently and kind of started to wonder how such companies serve videos to their consumers. That is where I started to going down the rabbit hole of how videos are served and how to try to ensure the possibility that videos can be played without requiring to download the entire video.

Trying cooklang with Golang to document recipes

Mon, 20 Mar 2023 00:00:00 +0000

For many people, cooking is not just a means of sustenance but a beloved hobby and a way to express creativity in the kitchen. However, one of the biggest challenges for home cooks is keeping track of their recipes and possibly the list of interesting recipes from other people. In my opinion, it’s general a good idea to have a copy of such information on hand (since websites/videos hosting such recipes can eventually disappear). However, recording such information in plain text might be a tad “boring” - it’s also harder to kind of parse as well as process further. In this blog post, we will explore using cooklang as a possible tool to “standardize” such information.

Custom Endpoint for Google Analytics data with Golang

Tue, 28 Feb 2023 00:00:00 +0000

Introduction
#

I used to work with Google Analytics to obtain site analytics for websites and android application. Technically, the current blog is monitored using Google Analytics. Monitoring of website data is generally useful as it provides information to the authors of the website/website owners on what particular content that website visitors find the most useful. With such information, it makes easier for the owner to try to add new content that attempts to provide such relevant content to visitors which would hopefully spur a virtuous cycle of gaining more audience for the website.

Trying out Google Cloud Workflows

Mon, 10 Oct 2022 00:00:00 +0000

Over the recent weekends, I’ve decided to take a gander and try another “serverless” tool called Google Cloud Workflows. The tool’s appeal is to be able coordinate a bunch of services in order to achieve a particular goal. The coordination effort (or workflow) can easily get pretty complex -> one way would be to script but if we want to have the capability to have the button to run the entire workflow from start to end with logging in place as well as capability to run the workflow based on particular triggers.

Leader Election in Kubernetes via Kubernetes Configmaps and Leases

Sun, 28 Aug 2022 00:00:00 +0000

The leader election mechanism is a somewhat complex thing to kind of code up for an application. There are various Golang libraries that assist with this but it would be nicer if there were mechanisms within the environment that the application operate in which can help with this. In the case for the Kubernetes ecosystem - we can actual rely on the fact of how Kubernetes would usually etcd that does this leader election dance on our behalf. If we can tap on this mechanism, we can avoid introducing this mess of a complexity within our application.

Continuous Profiling of Applications in Kubernetes via Pyroscope

Fri, 05 Aug 2022 00:00:00 +0000

The whole process of profiling an application is an attempt to identify hotspots within the application which consumes more resources or takes too much time - knowing this would allow us to identify how to further improve the code within the applications that we build in order to build applications that consume less resources or would respond better to external inputs. Profiling of an application is just another aspect to improve observability of application’s performance on top of the common usual tooling such as distributed traces, metrics and logs. Tools such as distributed traces, metrics and logs only can capture part of the picture of how an application performs within an environment but is different for profiling. Profiling would point out what is happening “internally” within the application such as amount of memory being allocated for particular functions, how much CPU time is being taken for a particular function, thereby providing even more visiblity to how the application works.

Fake Redis Server built with Golang

Wed, 20 Jul 2022 00:00:00 +0000

A friend of mine once mentioned about one of the tasks that he had to go through during his programming days was to build out a server which would respond to the redis-cli tool and I started to think - “that’s something I’ve never done before… I wonder how hard it is?” After a day of tinkering around - it’s definitely something that’s not “intuitive” to immediately get done; there are definitely some concepts that I’m not super clear about but it’s definitely something that can be slowly built out while learning various concepts.

Coding out Self Balancing Tree data structures

Thu, 07 Jul 2022 00:00:00 +0000

Over the past month, I decided to go down the rabbit hole of exploring an example of a self balancing tree data structure. I generally don’t need to handle data structures on a day to day basis - I mostly deal with integration of tools as well as deployment of tools into a Kubernetes cluster. However, even if I don’t deal with that side of things, I do find that some of the thought process behind the data structures and algorithms are pretty interesting. (I’m still kind of waiting for a moment where I can actually utilize it in my work for real in a way)

Debugging Distroless Kubernetes Pods

Fri, 15 Apr 2022 00:00:00 +0000

There is a trend of images that follow the philosophy of minimizing the size of image by removing almost everything out of image. This helps with getting image downloaded more quickly by kubelet into the nodes as well as possibly reducing the attack surface of the container even further (I suppose it’s harder to do things in a container if utilities like shell or bash don’t exist within it). You would probably see errors such as this for those containers that have somewhat remove the shell/bash:

Kubernetes Ingress for applications with branded links on GKE

Sun, 13 Feb 2022 00:00:00 +0000

While dealing with branded links during my course of work, I kind of wondered how it can be tackled if I were to do it in a Google Kubernetes Engine Cluster. The situation I would imagine that would need to solve is this:

Bus Arrival App - Singapore

Thu, 03 Feb 2022 00:00:00 +0000

This is a quick sample tool to retrieve bus arrivals in Singapore. In order to use it, we would need to find for the Bus Stop ID or Bus Stop Code from where we’re taking the bus from. After keying it, it would fetch the records from LTA Datamall’s real time bus arrival API and present those records in this tool.

Database migration via Cloud SQL Proxy for Cloud SQL in Google Compute Engine VM

Mon, 17 Jan 2022 00:00:00 +0000

Database migration is kind of a critical bit when it comes to running and operating applications. In Golang, it is kind of appealing to rely on ORM (Object Relational Mapping) libraries. It allows one to kind of map structs to tabular structures within the database storage. One such example of an ORM library that I’ve found on the first page of Google is GORM.

CORS with Golang Microservices and Elm Frontend is difficult

Sun, 02 Jan 2022 00:00:00 +0000

I am still building up my personal pet project: https://github.com/hairizuanbinnoorazman/slides-to-video; the aim of this project is a personal one - to build up a set of microservices that is able to be deployed in various ways such as locally via Docker Compose or even to Kubernetes or the serverless Cloud Run platform on Google Cloud Platform. There was a previous blog post describing an initial part of this journey: Lessons on building the project - Part 1

Build Chat App with Golang Websocket and Elm Frontend

Mon, 20 Dec 2021 00:00:00 +0000

While building Elm based frontends, I decided to take the opportunity to learn on how to craft a chat application. Truthfully, I’ve never really built one before (nor do I need to). But it does seem like an interesting programming exercise to kind of go thru - in order to understand how such applications are built, deployed, scaled and managed. For the frontend, I’m mostly set to use Elm (probably you’ve seen a previous post on my “dislike” for other Javascript based frameworks, which is essentially all the popular ones in the market). For backend, I will probably stick to Golang since that is the language I’m most comfortable with (all hail statically typed languages)

Using systemd to manage services

Thu, 10 Jun 2021 00:00:00 +0000

What and why systemd?
#

Systemd is a convenient set of tooling that can be used to manage services and applications on a linux server. When we are managing applications on a server, we would want the following properties automatically for most application - the requirements are somewhat for most applications:

Lessons from building Slides to Video App - Part 1

Sun, 28 Feb 2021 00:00:00 +0000

A long time back, sometime in 2019 (which is almost an eternity ago ), I kind of did up an application that can take some slides saved in a pdf file and generate a video out of it. I kind of talked about it in a lightning session during the following event at Google Devspace https://events.withgoogle.com/la-kopi-serverless/. The input to the application would be the slides in a pdf format as well as some sort of “script”. The words in the script would be used to generate the voiceover and then it would be used as part of the video. Essentially, the aim of the app would be create a “presented” version of the slides in a video form without requiring a person to present it. Everything about it is just generated via tools/products available on GCP.

Automating the admin work when organizing webinars in a meetup group

Thu, 01 Oct 2020 00:00:00 +0000

There is actually plenty of work that needs to be done in order to continuously and consistently organize webinars in a meetup group. I am involved in one of them and it takes quite a bit of effort to maintain such effort to ensure that the group look “alive” with webinars being continuously churned out during this unique situation.

Implications for having switchable loggers

Sun, 16 Aug 2020 00:00:00 +0000

Loggers in codebases are generally code that is just taken for granted. We would usually imagine that we’ll just choose a logger library, import it and then just utilize in code. We would probably have the application pass some configuration to the application, maybe to reduce amount of logs printed in production to reduce the amount of load that it would produce in logging aggegration systems.

Dockerizing application that use unix sockets

Sun, 12 Apr 2020 00:00:00 +0000

While trying to understand how components that deal with Container Storage Interface (CSI) in Kubernetes, I came across mentions of how the components were using Unix domain sockets to communicate with each other. A quick read on why unix domain sockets seem to reveal that its use is to reduce the amount of overhead while such components talk to each locally. If the components had required to talk across to multiple nodes, it would have used TCP instead.

Golang composition

Fri, 10 Jan 2020 00:00:00 +0000

These are some notes I took while experimenting and playing around with Golang further. This article is mainly exploring embedded structs and interfaces to experiment how they work etc.

Use Golang playground in order to see how it works in action

Private Go Modules in Google Cloud Build

Fri, 01 Mar 2019 00:00:00 +0000

So recently, I’ve been needing to automate my builds for my few Golang projects via Google Cloud Build. However, rather than building docker containers, I needed Golang binaries instead, which kind of meant that I would need to have the CI/CD pipeline have a Go environment/runtime to build them. However, when it comes to these CI/CD solutions, including private Golang packages/modules in siad projects is usually quite troublesome. Private Golang packages usually take the code from private Github/Bitbucket/Gitlab repos and getting the go get command to fetch them successful require a bit of hacks here and there to make it work successfully.

Things to watch out for in 2019

Thu, 10 Jan 2019 00:00:00 +0000

The list would be updated as time goes by in the year

A list of conferences and meetups and exhibitions to look for especially in 2019:

This kind of personal list that I’m keeping track; it mainly revolves around Golang, modern architecture technologies e.g. Cloud technologies etc, Python and even R (One of my initial language, I still do keep a lookout of how it’s doing nowadays.)

Using nginx to serve as ingress to multiple servers

Sat, 29 Sep 2018 00:00:00 +0000

This is a little experiment to see how this would work; in the case where we have multiple Go binaries with multiple web applications. If we wanted to expose this via a single http endpoint rather than providing a whole multitude of web endpoints.

Trying out skaffold

Thu, 09 Aug 2018 00:00:00 +0000

When developing application that are meant to be deployed to the Kubernetes platform, it involves a bunch of steps on top of your usual local development work:

Writing a Dockerfile to package the application (Multi stage applications are optional here - useful for compiled based languages)
Build and tagging the docker image of the application with the target repository
Either use kubectl commands or use kubernetes config resource files to define the resources required for deploying the applications. Use those commands/configurations to define the resources on the staging/production application
Repeat the process for each update of the application (Repeat second point onwards)

As you see from above, it starts to be pain to do so after each iteration of the application development. The building of the docker containers process as well as the applying of the new images to each cluster, (sometimes with slightly changed configuration files) - the kubernetes secret and config files can change across different environments.

Lessons from Kubecon/CloudNativeCon 2018 Europe

Wed, 16 May 2018 00:00:00 +0000

The following set of summaries are from the Kubecon and Cloud Native Con Europe in Denmark from 2-4 May 2018.

These summaries are from conference talks that I thought provided more interesting thinking points.

Lessons from Gophercon SG

Wed, 09 May 2018 00:00:00 +0000

This is the list of talks provided in the reccent Gophercon Conference held in Singapore on 4th May 2018

Go with Versions
Project-driven journey to learning Go
Resilency in Distributed Systems
Understanding Running Go Program
Go for Grab
Optimize for Correctness
Build your own distributed database
The Scandalous Sotry of Dreadful Code Written by the Best of Us
Erlang for Go developers
Go and the future of offices
Reflections on Trusting Trust for Go
The lost art of bondage

Below are some of the more interesting points raised during the talk (View the full talk to understand the context on what and why a certain point was raised.)

Let's use CLI to create Tasks!!

Sun, 22 Apr 2018 00:00:00 +0000

Out of random curiousity and laziness on my part, I decided to create a CLI tool which would allow me to create tasks on task managements websites such as on Asana, and issues in Github/Bitbucket.

A sample bookcase application case via Gin Golang Framework

Thu, 08 Mar 2018 00:00:00 +0000

This is an application based on a previous blog post on Bookcase application.

The link to the code base of the application:

https://github.com/hairizuanbinnoorazman/golang-web-gin-book-store

There is a chance that when you are on the code base, the application is not fully operational; I am still adding code to it to add functionality to the application

A sample bookcase application case

Wed, 07 Mar 2018 00:00:00 +0000

We would try to implement the various technology stack for some common web application scenario in several types of libraries. In our case here, we would attempt to implement it for the following scenario.

Favourite Golang Resources

Wed, 28 Feb 2018 00:00:00 +0000

This is a personal list of Golang Resources I like to keep track. This is a evergreen list so I will update it once in a while when new stuff pops up.

Refactoring Go Safely

Wed, 21 Feb 2018 00:00:00 +0000

An excellent resource to read on Refactoring Golang code safely and to ensure that Golang code continue does not result in breaking changes in the codebase.
https://talks.golang.org/2016/refactor.article

An important to take away from the article is the fact that when making API changes to a code base, the portion that results in largest amount of work is the amount of code repair that needs to be done. Here are some of the examples to take note:

Things to watch out for in 2018

Wed, 14 Feb 2018 00:00:00 +0000

A list of conferences and meetups and exhibitions to look for especially in 2018:

Using Go in AWS Lambda

Mon, 15 Jan 2018 00:00:00 +0000

Disclaimer: There are definitely better ways of doing this; this is more of a lazy man’s way of doing it. This is just to explore the possibility of getting a golang application into AWS Lambda and successfully running it.

Using Go to post messages on Slack

Sun, 22 Oct 2017 00:00:00 +0000

A sample application to kind of get started with Go.

This application involves pinging a channel on Slack via a webhook. Slack provides a unique URL in order to ping Slack with messages from a script/application.

Golang on Experiment, Fail, Learn, Repeat

Adding SSO to MCP Grafana Server

Building a code assessment tool but in Kubernetes

Nginx as API Gateway - focusing on auth_request directive

Access Cloud SQL from Google Cloud Run without Serverless VPC Access Connectors but via VPC

Introduction #

Multiple Database Support - MySQL and SQLite support

Serverless Applications with Cloud Run with Serverless MySQL from PlanetScale

Access Cloud SQL from Google Kubernetes Cluster without Cloud SQL Proxy

Introduction #

Access Cloud SQL from Google Compute Engine without Cloud SQL Proxy

Storing Helm in Docker Registries

Python call Golang functions via Wasm/Wasi

Inspirations #

Writing code to store items in memory with Golang but with maps

Writing code to store items in memory with Golang

Using Emulators for testing Google Cloud Datastore integration

Motivation for finding emulator for Google Cloud Datastore #

Heap datastructure with Slices/Arrays in Golang

Deploy Golang Apps that interact with headless service in Kubernetes

Redis vs Memcached via Golang

Trying to create MariaDB replica server

Replicating golang interfaces with static python, run with mypy

Running database migrations in Helm chart

Using smaller base images for applications, slim images? alpine images? distroless images

Altering outputs of helm installations with post-renderer via kustomize

Updating configuration in Kubernetes pods managed via Helm

Consistent Hashing Implementation in Golang

Rethinking migrations in Golang Applications

Writing Rego Policies for authorization in Golang Apps

Serving Videos with Golang via HLS

Trying cooklang with Golang to document recipes

Custom Endpoint for Google Analytics data with Golang

Introduction #

Trying out Google Cloud Workflows

Leader Election in Kubernetes via Kubernetes Configmaps and Leases

Continuous Profiling of Applications in Kubernetes via Pyroscope

Fake Redis Server built with Golang

Coding out Self Balancing Tree data structures

Debugging Distroless Kubernetes Pods

Kubernetes Ingress for applications with branded links on GKE

Bus Arrival App - Singapore

Database migration via Cloud SQL Proxy for Cloud SQL in Google Compute Engine VM

CORS with Golang Microservices and Elm Frontend is difficult

Build Chat App with Golang Websocket and Elm Frontend

Using systemd to manage services

What and why systemd? #

Lessons from building Slides to Video App - Part 1

Automating the admin work when organizing webinars in a meetup group

Implications for having switchable loggers

Dockerizing application that use unix sockets

Golang composition

Private Go Modules in Google Cloud Build

Things to watch out for in 2019

Using nginx to serve as ingress to multiple servers

Trying out skaffold

Lessons from Kubecon/CloudNativeCon 2018 Europe

Lessons from Gophercon SG

Let's use CLI to create Tasks!!

A sample bookcase application case via Gin Golang Framework

A sample bookcase application case

Favourite Golang Resources

Refactoring Go Safely

Things to watch out for in 2018

Using Go in AWS Lambda

Using Go to post messages on Slack

Introduction
#

Introduction
#

Inspirations
#

Motivation for finding emulator for Google Cloud Datastore
#

Introduction
#

What and why systemd?
#