Site Reliability Engineer Blog

Projects & Open Source

Fri, 23 Oct 2026 00:00:00 +0000

A curated catalog of open-source projects, cloud reliability guides, architectural experiments, and upstream contributions. Source code and activity are hosted on GitHub: @vorozhko.

Uses

Fri, 23 Oct 2026 00:00:00 +0000

A breakdown of the physical hardware, terminal cockpit, Kubernetes & IaC tooling, agentic workflows, and daily software I rely on for Site Reliability Engineering, platform architecture, and software development. Inspired by uses.tech.

Books I Read

Tue, 20 Oct 2026 00:00:00 +0000

Books from my Goodreads “read” shelf.

How to recognize Great Work

Sun, 27 Sep 2026 10:47:37 +0000

Evaluating performance isn’t about tracking hours or micromanaging, it’s about looking at two simple things: What you deliver and How you work with the team.

Both matter equally. Delivering great results with a toxic attitude doesn’t work, and being super friendly without ever finishing tasks doesn’t work either.

Here is what defines great results:

1. Great Outcome (The “What”)

Great outcomes mean delivering work above expectations without causing headaches down the line.

Bullet proofing Agentic Engineering

Thu, 04 Jun 2026 13:47:25 +0000

I’m in the same boat as a lot of engineering teams right now: most of my code is agent-written, and there is no human capacity to review all of it line by line. That leaves two choices, and neither is a good choice:

Wait for human review — and fall behind on delivery.
Merge without review — and quietly lower the quality bar.

So at McMakler we picked a third option: stop reviewing the code, and start building the machine that reviews it for us. Back to the drawing board to design a CI/CD system that guarantees every change clears a minimum quality baseline — without a human reading every diff.

About

Thu, 01 Jan 2026 00:00:00 +0000

What I care about

People: I use RFCs, OKRs, Kanban and Scrum when they help, and I make continuous learning part of the job.
Reliability: Service level objectives and error budgets let engineers and the business talk about risk in the same language.
Automation: If I do something by hand twice, I automate it. If the automation breaks, I fix it.
Security: It has to be there at every level: cloud, cluster, container and application code. That means access control, secrets management, multi-tenancy and a tested incident process.
Platforms: Infrastructure as code, GitOps and CI/CD let teams test in ephemeral preview environments and ship with confidence.
AI with guardrails: AI makes teams faster, but only when there are real tests and checks behind it.

Experience

2020 – present · McMakler

McMakler is the story of building a strong team and a strong platform. I lead the DevOps team. We run the Kubernetes platform on Google Cloud and AWS, observability, incident management, CI/CD and databases. Along the way my technical direction formed the platform which now supports hundred of services and many Merge requests a day to get build and deployed with the help of AI.

Improving Team Performance Measurement: A DORA and SLO/SLI Approach

Sun, 16 Nov 2025 14:55:56 +0000

As a DevOps manager, measuring your team’s performance and impact is crucial for guiding the next year’s roadmap. By applying proven practices like the DORA research combined with SRE tools such as SLOs (Service Level Objectives) and SLIs (Service Level Indicators), you can design a highly practical approach to team performance evaluation.

DORA and SLO/SLI Practices

There are several frameworks which can guide you through measuring team performance, but I prefer DORA research paired with SLO/SLI and Error Budgets due to their simplicity and practical application.

The Reality of Self-Hosting AI model for Code Suggestions

Thu, 30 Oct 2025 18:28:51 +0000

Recently I had a pleasure to test self-hosted AI model with RAG support for code suggestion task. Results as most predicted: the cost/performance ratio for small teams are still in favors of proprietary solutions.

Here’s a breakdown of the hardware, quality, and cost realities for teams considering open-source Large Language Models (LLMs) with Retrieval Augmented Generation (RAG) support.

💸 The High Cost of the “Free” Model

While the models themselves (like Qwen or Mistral) are open-source, the Total Cost of Ownership (TCO) for the required infrastructure quickly escalates, making small, self-hosted LLMs surprisingly inefficient.

Kubernetes operators quick start

Sun, 11 May 2025 11:13:54 +0000

Kubernetes operator provide easy and simple way to extend Kubernetes cluster with additional functionality.

For example you might find that you need custom operator in areas like:

Managing stateful applications: take any Database, Message Queue or Cache as example, it needs full lifecycle of operations to be good for production. For a long time running databases in Kubernetes was an anti-pattern, but with operators things started to changed.
Automating Application Lifecycle Management: the complexity of making new application can be overwhelmed for your development teams, so why not to introduce something more simple with just few core fields which are shared between all applications.
Enhancing Observability: operators like Prometheus operator or Alermanager hides complexity of managing these tools and provide simple interface to get started quick.
Automated Backup, Restore, and Disaster Recovery: For stateful applications, operators can automate the process of taking regular backups, storing them securely, and orchestrating the restoration process in case of data loss or system failure.
CI/CD and GitOps Automation: operators play crucial role in GitOps workflow. Tools like the Pulumi Kubernetes Operator enable managing infrastructure alongside Kubernetes workloads.
Networking and Security Management: Operators for service meshes like Istio or Linkerd simplify their installation, configuration, and upgrades across the cluster.
Building Platform-as-a-Service (PaaS)-like Capabilities: By abstracting away underlying Kubernetes resources, operators can provide a simplified, application-centric interface for developers, similar to what a PaaS offers.

Writing your own operator

If you think to get started to write your own operator it’s good to know what any operator consist of:

Solving Top-K problem - Leaderboard in Python

Mon, 21 Apr 2025 15:38:24 +0000

What is Top-K problem?

Think about Real-time Gaming Leaderboard with a rank system. Determining the rank of a player is a problem we are trying to solve. This is implementation of Real-time Leaderboard solution from the System Design interview book. Check out full source code at Leaderboard - solving Top K Problem with Python Github project.

Leader board requirements

Get top 10 ranked players
Show a current rank for each player
Show a slice of players around specific rank

Solution 1: using SQL database

Direct approach is to use SQL kind of database and count rank in real time using count until Player score points >= all other players. This solution fall short as soon as we need to scale it for high number of players.

LLM-Powered Unit Testing: Effortlessly Generate Domain Model Data

Sat, 05 Apr 2025 13:49:32 +0000

Traditional approaches to generating model data for unit tests often involve setting up complex fixtures or writing cumbersome mock classes. This becomes especially challenging when your domain model is tightly coupled with your data mode.

class Order(Base):
 # ...
 product_name = Column(String, index=True)
 quantity = Column(Integer)

In more advanced scenarios, your Domain model is decoupled from the Data model, allowing for cleaner architecture and improved maintainability.

class Order(BaseModel):
 product_name: str
 quantity: int

def testOrder(self):
 order = Order(product_name="Milk", quantity=2)
 self.assertEqual(order.quantity, 2)

Using hard-coded data can be a sub-optimal approach. Every modification to the Domain model requires updates to the test suite.

🚀 Supercharge Your Python Code Reviews: Automate with GPT and OpenAPI Endpoints

Sat, 29 Mar 2025 20:00:03 +0000

A common approach to getting code reviews with ChatGPT is by posting a prompt along with a code snippet. While effective, this process can be time-consuming and repetitive. If you want to streamline, customize, or fully automate your code review process, meet gptscript.

Gptscript is a powerful automation tool designed to build tools of any complexity on top of GPT models.

At the core of gptscript is a script defining a series of steps to execute, along with available tools such as Git operations, file reading, web scraping, and more.

Tech Team Leaders' Guide to Strategy

Mon, 24 Mar 2025 16:28:25 +0000

Building a tech strategy is a core responsibility of the CTO, VP of Engineering, or Head of Engineering. Involving team leaders in this process ensures a more grounded and effective approach.

Tech team leaders play a crucial role by defining roadmaps for their teams, which, in turn, provide the foundation for an effective high-level strategy. To achieve the best results, continuous collaboration between leadership and team leaders is essential.

Let’s explore how to create a roadmap that is both practical and aligned with the company’s overall vision.

Collecting Datadog APM traces using Grafana Alloy and Tempo

Thu, 20 Mar 2025 20:29:16 +0000

The Problem

Hybrid cloud is the future, but monitoring remains stuck in the past. Many organizations embrace hybrid infrastructure, yet struggle with fragmented observability tools. Why? Because monitoring providers still operate in silos.

One of the primary reasons hybrid monitoring isn’t as prevalent is the challenge of instrumentation. Many cloud providers offer their own monitoring solutions. Instrumentation libraries are often incompatible with one another, making cross-platform integration difficult.

The good news? With OpenTelemetry, Grafana, and Datadog, hybrid monitoring is becoming easier and more flexible. 🚀

Cost saving strategy for Kubernetes platform

Mon, 17 Mar 2025 19:17:54 +0000

Working on cost saving strategy involves looking at the problem from very different dimensions. Overall Kubernetes costs can be split on compute costs, networking costs, storage costs, licensing cost and SaaS costs. In this part I will cover: Right-size infrastructure & use autoscaling

Right-size infrastructure & use autoscaling

Kubernetes Nodes autoscaler

In a cloud environment Kubernetes Nodes autoscaler plays important role in delivering just enough resources for your cluster. In a nutshell:

Multi provider DNS management with Terraform and Pulumi

Tue, 04 Mar 2025 14:04:58 +0000

The Problem

Every DNS provider is very specific how they create DNS records. Using Terraform or Pulumi don’t guarantee multi provider support out of the box.

One example where AWS Route53 support values for multiple IP binding to the same name record. Where Cloudflare must have a dedicated record for each IP.

Theses API difference make it harder to write code which will work for multiple providers.

For AWS Route53 a single record can be created like this:

Grafana a new look

Fri, 24 Jan 2025 19:59:06 +0000

As much as l like managed monitoring solutions it’s hard not to be excited about setting up your own platform based on Prometheus Grafana stack and save some bucks for the company.

After 5 years of using proprietary solutions I am again on the way to get into Grafana world.

Here I want to wrap up what I learnt so far about Grafana.

Big ecosystem of tools

The biggest change for me is ecosystem of projects which supports almost all imaginable monitoring needs.

Can ArgoCD replace Helm managers?

Sat, 30 Sep 2023 13:24:24 +0000

ArgoCDis a tool which provides GitOps way of deployment. It supports various format of applications including Helm charts.

Helm is one of the most popular packaging format for Kubernetes applications. It give a rise to various tools to manage helm chart like helmfiles, helmify and others.

Why ArgoCD is replacing Helm managers?

For a long time Helm managers help to deploy Helm charts via different deploy strategies. It serves well, but the big disadvantage was a code drift which accumulate over time.

Path to Staff Engineer role

Sat, 16 Sep 2023 14:20:08 +0000

Someday in your career you take your time to think what’s next for me? What is my next challenge to grow in a career ladder? If your answer is Staff Engineer, Tech lead, Team lead or Principal Engineer then you are on the way to Staff-plus Engineer role.

As a Staff-plus Engineer myself I want to share my few tips for you.

Start working on Staff engineer package

What’s your Staff level project? * What did you do and what was impact? * What behavior did you demonstrate and how complex projects were?
Link your Design Documents, RFCs and Proposals to support your package with your design and architecture contribution.
Can you quantify the impact of your projects? * Did it helps to increase revenue? * Save costs?
What glue work did you do to organization? * What’s the impact of the glue work?
Who have you mentored and through what accomplishments?

Sharpen your soft skills

Communication. * Keep people informed and connected.
Negotiation * Be ready to resolve difficult situations
Presentation * Know your audience. Learn one or two presentation frameworks.
Networking * Don’t be shame to get in touch with other Staff-plus engineers in your company. * They are the best people to help you navigate the role inside the company.

Learn Staff Engineer tools

Leadership * Become a problem solver. Be a visionary in your area. Stay up to date with technologies in your area.
Planning and Goal orientation * Have a vision of what you do next in one or another area. * Take active participate on Planning meetings.
Collaboration and contribution * Propose new Decision docs, Proposals and RFCs. Make sure they are reviewed and discussed. * Implement POC to demo the idea out.
Team work and mentorship * Help your peers. Be a problem solver. Be visible. Become a go to person. * Try on a mentorship role.

Summary

Getting Staff engineer role could take months or years to accomplish. However, it’s crucial to view this milestone not as the ultimate destination, but rather as a guiding roadmap for your career development. It’s not the title itself that holds the most significance, but rather the daily challenge we face and the positive impact we make as we progress in our journey.

Certified Kubernetes Administrator

Sat, 17 Apr 2021 13:21:08 +0000

The CKA exam was a real challenge and great experience over all.

My first impression now I am officially part of Kubernetes world and CNCF.

But, I just love Kubernetes and it’s eco-system of open source projects and I had a lot of fun during my preparation and CKA exam. When you combine work with fun you can achieve really great results.

My advise for all future CKA participants is to have 80% of real Kubernetes practice and other 20% you can learn along the exam year.

Implementing RED method with Istio

Wed, 08 Jul 2020 09:20:02 +0000

In this article I describe how to quickly get started with SLO and SLI practice using Istio. if you are new SLO and SLI read a Brief Summary of SRE best practices.

RED or Rate Errors Duration

The RED method is an easy to understand monitoring methodology. For every service, monitor:

Rate - how many operations per second is placed on a service Errors - what percentage of the traffic return in error state Duration - the time it take to serve a request or process a job

Brief Summary of Site Reliability Engineering best practices

Fri, 26 Jun 2020 12:31:40 +0000

The goal of SRE is to accelerate product development teams and keep services running in reliable and continuous way.

This article is a collection practical notes on explaining what is SRE, what kind of work SREs does and what type of processes they develop. The practices are based on Google SRE workbook.

This is a long article and If you will make it to the end I applaud to you!

Simple LRU cache implementation on Python 3

Wed, 24 Jun 2020 15:22:21 +0000

What is LRU Cache?

This is caching item replacement policy, so the least used items will be discarded first.

Problem

The LRU Cache algorithm requires keeping track of what was used when, which is expensive if one wants to make sure the algorithm always discards the least recently used item.

Solution

Approaching a problem I was thinking of two capabilities for data structures: a FIFO queue and Hash table.

FIFO queue will be responsible to evict least used items. Hash table will be responsible to get cached items. Using this data structures make both operations in O(1) time complexity.

Filebeats configuration for Kubernetes

Mon, 08 Jun 2020 14:30:46 +0000

filebeat.autodiscover:
 providers:
 - type: kubernetes
 node: ${NODE_NAME}
 hints.enabled: true
 hints.default_config:
 type: container
 paths:
 - /var/log/containers/*${data.kubernetes.container.id}.log

What’s so cool about above configuration

Filebeat Autodiscover

When you run applications on containers, they become moving targets to the monitoring system. Autodiscover allows you to track them and adapt settings as changes happen.

The Kubernetes autodiscover provider watches for Kubernetes nodes, pods, services to start, update, and stop. As well it recognise a lot of additional labels and statuses related to Kubernetes objects.

Integrating Flask with Jaeger tracing on Kuberentes

Sat, 06 Jun 2020 08:40:00 +0000

Distributed applications and microservices required high level of observability. In this article we will integrate a Flask micro framework with Jaeger tracing tool. All code will be deployed to Kubernetes minikube cluster.

Flask

Let’s build a simple task manager service using Flask framework.

Code

tasks.py

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/')

tasks = {"tasks":[
 {"name":"task 1", "uri":"/task1"},
 {"name":"task 2", "uri":"/task2"}
 ]}

def root():
	"Service root"
	return jsonify({"url":"/tasks")

@app.route('/tasks')
def tasks():
	"Tasks list"
	return jsonify(tasks)

if __name__ == '__main__':
 "Start up"
 app.run(debug=True, host='0.0.0.0',port=5000)

I have skipped other CRUD operations for simplicity.

Backup and restore of Etcd cluster

Wed, 20 May 2020 09:13:30 +0000

Kubernetes disaster recovery plan is usually consist of backing up etcd cluster and having infrastructure as a code to provision new set of servers in the cloud. Let’s see how to do first - backup etcd in two basic and easy ways.

Etcd backup

The only stateful component of Kubernetes cluster is etcd server. The etcd server is where Kuberenetes store all API objects and configuration. Backing up this storage is sufficient for complete recovery of Kubernetes cluster state.

Having fun with Kubernetes deployment

Tue, 19 May 2020 12:43:09 +0000

Install deployment

Install nginx 1.12.2 with 2 pods

If you need to have 2 pods from the start then it could be done in three easy steps:

Create deployment template with nginx version 1.12.2
Edit nginx.yaml to update replicas count.
Apply deployment template to Kubernetes cluster

# step 1
kubectl create deployment nginx --save-config=true --image=nginx:1.12.2 --dry-run=client -o yaml > nginx.yaml
# step 2
edit nginx.yaml
# step 3
kubectl apply --record=true -f nginx.yaml

Notice use of --record=true to save the state of what caused the deployment change

How to check Kubernetes cluster health?

Mon, 18 May 2020 07:30:36 +0000

There are some essential tools to have a quick look at Kubernetes cluster health. Let’s review them here. As a result you would be able quickly tell if cluster has any obvious issues.

Install node problem detector

node-problem-detector aims to make various node problems visible to the upstream layers in cluster management stack. It is a daemon which runs on each node, detects node problems and reports them to apiserver.

Multi node Kubernetes cluster on Vagrant

Sun, 17 May 2020 19:43:50 +0000

This is fast and easy way to install Kubernetes on Vagrant with Metrics server addon.

git clone https://github.com/vorozhko/practical-guide-to-kubernetes-administration-exam
cd vagrant/kubernetes
vagrant up

At this point you would have one master node and two worker nodes ready.

Lets check cluster health

vagrant ssh master

kubectl get nodes
NAME STATUS ROLES AGE VERSION
master Ready master 2m46s v1.18.2
worker1 Ready <none> 35s v1.18.2
worker2 Ready <none> 32s v1.18.2

All nodes are ready.

Build Kubernetes control plane image with Packer

Fri, 08 May 2020 12:20:25 +0000

Steps to prepare single control plane image is quite simple:

Prepare Docker and Kubernetes packages and settings
Execute kubeadm bootstrap script when EC2 start up first time

One unanswered question is: How to add additional control plane nodes and worker nodes which required tokens and certificates to be preset when joining the cluster?

Packer builders

Builders section define base image, EC2 instate type and other settings to build an image.

Practical guide to Kubernetes Certified Administration exam

Mon, 27 Apr 2020 13:39:41 +0000

I have published practical guide to Kubernetes Certified Administration exam https://github.com/vorozhko/practical-guide-to-kubernetes-administration-exam

Covered topics so far are:

If your are also working on preparation to Kubernetes Certified Administration exam lets combine our efforts by sharing the practical side of exam.

Disaster recovery of single node Kubernetes control plane

Tue, 21 Apr 2020 05:42:31 +0000

Overview

There are many possible root causes why control plane might become unavailable. Lets review most common scenarios and mitigation steps.

Mitigation steps in this article build around AWS public cloud features, but all popular public cloud offerings have similar functionality.

Apiserver VM shutdown or apiserver crashing

Results

unable to stop, update, or start new pods, services, replication controller
existing pods and services should continue to work normally, unless they depend on the Kubernetes API

Mitigations

In case of apiserver crash

Apiserver is a POD, so it’s responsibility of kubelet to restart the pod.
Kubelet itself is monitored by systemd which will restart kubelet in case of failure.

In case of VM shutdown

AWS Cloudwatch approach based on instance status check:

Thoughts on High available Kubernetes cluster with single control plane node

Thu, 16 Apr 2020 06:03:44 +0000

Why single node control plane?

Benefits are:

Monitoring and alerting are simple and on point. It reduce the number of false positive alerts.
Setup and maintenance are quick and straightforward. Less complex install process lead to more robust setup.
Disaster recovery and recovery documentation are more clear and shorter.
Application will continue to work even if Kubernetes control plane is down.
Multiple worker nodes and multiple deployment replicas will provide necessary high availability for your applications.

Disadvantages are:

Go http middleware chain with context package

Sat, 14 Dec 2019 20:44:43 +0000

Middleware is a function which wrap http.Handler to do pre or post processing of the request.

Chain of middleware is popular pattern in handling http requests in go languge. Using a chain we can:

Log application requests
Rate limit requests
Set HTTP security headers
and more

Go context package help to setup communication between middleware handlers.

Implementation

Middleware chain

To compose handlers into a chain I choose Alicepackage which implement logic of looping through middleware functions.

How to enable minikube kvm2 driver on Ubuntu 18.04

Tue, 10 Dec 2019 13:09:43 +0000

Verify kvm2 support

Confirm virtualization support by CPU

 egrep -c ‘(svm|vmx)’ /proc/cpuinfo

An output of 1 or more indicate that CPU can use virtualization technology.

sudo kvm-ok

Output “KVM acceleration can be used. " indicate that the system has virtualization enabled and KVM can be used.

Install kvm packages

 sudo apt-get install qemu-kvm libvirt-bin bridge-utils virt-manager

Start libvirtd service

 sudo service libvirtd start

Add your user to libvirt and kvm group

sudo adduser `id -un` libvirt
sudo adduser `id -un` kvm

and re-login the user

Istio sidecar injection

Sun, 22 Sep 2019 13:38:44 +0000

There are several ways to inject istio sidecar configuration into Pods. For example: automated injection, YAML/JSON deployment update, using Helm or Kustomize and update of existing live deployment. We will look into each of them.

Automatic Sidecar injection

Istio uses ValidatingAdmissionWebhooks for validating Istio configuration and MutatingAdmissionWebhooks for automatically injecting the sidecar proxy into user pods.

For automatic side car injection to work admissionregistration.k8s.io/v1beta1 should be enabled:

$ kubectl api-versions | grep admissionregistration.k8s.io/v1beta1
admissionregistration.k8s.io/v1beta1

Step two is to verify MutatingAdmissionWebhook and ValidatingAdmissionWebhook plugins are listed in the kube-apiserver –enable-admission-plugins. That can be done by cluster administrators.

How to organize Namespaces in Kubernetes

Sat, 14 Sep 2019 13:27:44 +0000

There are two main objectives:

Users are able to do their job with the highest velocity possible
Users organized by groups in multi tenant setup

Multi tenancy

Kubernetes namespaces help to setup boundaries between groups of users and applications in a cluster. To make it more pleasant and secure for your users to work in shared cluster Kubernetes has a number of policies and controls.

Access policies

RBAC primary objective is authorize users and applications to do specific operations in the namespace or in whole cluster. Use RBAC to give your users enough permissions in the namespace, so they can do day to day operations on their own. Network Policy control how pods can communicate with each other. Use it to firewall traffic between namespaces or inside namespace to critical components like Databases.

120 Days of AWS EKS in Staging

Sun, 03 Feb 2019 15:08:11 +0000

My journey with Kubernetes started with Google Kubernetes Engine then one year later with self managed kuberntes and then with migration to Amazon EKS.

EKS as a managed kubernetes cluster is not 100% managed. Core tools didn’t work as expcted. Customers expectation was not aligned with functions provided. Here I have summarized all our experience we gained by running EKS cluster in Staging.

To run EKS you still have to:

Production Readiness Checklist

Fri, 18 Jan 2019 17:00:01 +0000

In bookmarks - production readiness checklist. Very good job by Gruntwork !

Amazon EKS Workshop

Thu, 17 Jan 2019 17:00:32 +0000

I really hesitated to post aboutAmazon EKS workshop, but this one is really looking good and it is free and open source!

Going through workshop you will learn how:

Setup manager kubernetes cluster in AWS
Spin up services and deploy micro services
Autoscaling
Deployment with Helm charts
Continuous integration and continuous deployment
Monitoring and logging
Istio service mesh

First class incident response process

Wed, 16 Jan 2019 19:39:19 +0000

If you don’t have incident response process the chances are that sooner than later you will need one.

To understand where to start check out this first class incident response process documentation. It cover:

how to prepare to incident
what actions to take during incident
what are post incident steps

Kubernetes Ingress controllers - spreadsheet

Fri, 11 Jan 2019 19:00:21 +0000

Nice spreadsheetof all types of ingress controllers available for Kubernetes. Details are very well explained in Steven Acreman post.

Serve a golang web application over HTTPS in one line

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

This is next level of dealing with certificates. Great job by Matt Hold and open source community on Certmagic module.

Read his twitter thread on the subject.

AWS Transit Gateway to Simplify Your Network Architecture

Wed, 09 Jan 2019 21:00:40 +0000

This is how your network architecture probably looks now

this is how it can be with Transit Gateway

Transit gateway was one of the missing peaces to full fill network administration needs.

Amazon EKS IAM based authentication explained

Tue, 08 Jan 2019 20:26:39 +0000

One image worth 1000 words!

Read full article by Daniel Weibel on how authentication and authorization works on amazon EKS.

Terraform remote state and state locking

Sun, 05 Aug 2018 09:56:17 +0000

Terraform remote state and state locking is important part in team collaboration. What are challenges when working on Terraform in a team:

how to synchronize terraform state between people
how to avoid collisions of running terraform at the same time

Terraform remote state

Terraform remote state is a mechanism to share state file by hosting it on a shared resource like aws s3 bucket or consul server.

Example of storing state in s3 bucket.

AWS best practices for Lambda functions in Production

Mon, 16 Apr 2018 20:17:26 +0000

Hey folks,

just a month ago I have been involved in AWS project based on Lambda functions. In this article I will explain what I learned so far and how to create production Lambda AWS environment with best practices in mind.

I will start from top level and will explain everything you need to have basic infrastructure supporting your Lambda functions and other applications in your cloud.

VPC

First, you need to created dedicated VPC and reserve range of IPs which doesn’t conflict with your other networks in case you would need to pair them together. As a general rule you should never use default VPC for production needs. Create a security group which only allow 80 and 443 incoming traffic.

Kubernetes sidecar pattern: nginx ssl proxy for nodejs

Fri, 02 Mar 2018 10:34:20 +0000

I learn about sidecar pattern from Kubernetes documentation and later from blog post by Brendan Burns The distributed system toolkit. Sidecar is very useful pattern and work nice with Kubernetes.

In the tutorial I want to demonstrate how “legacy” application can be extend with https support by using sidecar pattern based on Kubernetes.

Problem

We have legacy application which doesn’t have HTTPS support. We also don’t want to send plain text traffic over network. We don’t want to make any changes to legacy application, but good thing that it is containerised.

Year 2017 in review

Sat, 20 Jan 2018 22:24:22 +0000

My 2017 in pictures.

First time in UK, so unusual to hear English everywhere after 5 years in Germany :)

Palma de Mallorca. For a May weather it was a great experience, I can’t imagine how good it is in summer. But, if you like me is a fun of active rest then May and June is the best time to go there.

calculating md5 sum using go lang

Mon, 18 Dec 2017 23:06:30 +0000

Hi guys, this is day 18 out of 100 days of code.

To get md5 sum of a file you crypto/md5 library and io/ioutil for reading files.

package main

import (
	"crypto/md5"
	"fmt"
	"io/ioutil"
	"log"
	"os"
)

func main() {
	if len(os.Args) <= 1 {
		log.Fatal("expected filename as parameter")
	}
	filename := os.Args[1]

	data, err := ioutil.ReadFile(filename)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("MD5 (%s) = %x\n", filename, md5.Sum(data))
}

Thanks!

Slow algorithm to insert strings into indexed file in alphabetical order

Mon, 11 Dec 2017 18:00:26 +0000

Hi guys, this is day 17 out of 100 days of code in go lang.

Today I have played with files, sorting, bytes and strings. The goal was to create a kind of indexed file where all lines are arranged alphabetically. What I got is very slow algorithm which took 15 seconds to insert 10K strings in an empty file and 49 seconds to insert another 10K strings to the same file. So, it slowdown very quickly as size grow.

Random image file download with go

Sun, 10 Dec 2017 13:31:38 +0000

Hi guys, this is day 16 out of 100 days of code.

With help of http and ioutil packages file download and storage is quite easy task.

package main

import (
	"io/ioutil"
	"log"
	"net/http"
)

func main() {
	url := "https://picsum.photos/200/300/?random"

	resp, err := http.Get(url)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	image, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	err = ioutil.WriteFile("./myimage.gif", image, 0644)
	if err != nil {
		log.Fatal(err)
	}
}

In the example I am using Lorem Picsum service to get random image every run.

Github issues reader in go lang

Sat, 09 Dec 2017 21:56:54 +0000

Hi guys, this is day 15 out of 100 days of go land coding.

I continue github subject and today it is github issue reader. Example demonstrate how API results which come in json format convert into struct type.

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net/http"
)

func main() {
	repo := flag.String("repo", "", "github owner/repo e.g. golang/go")
	id := flag.Int("id", -1, "issue id")
	flag.Parse()

	if *id == -1 || *repo == "" {
		log.Fatal("--repo and --id parameters must be provided")
	}
	issue, _ := read(*repo, *id)
	fmt.Print(issue.Title)
}

// IssueData - specify data fields for new github issue submission
type IssueData struct {
	Title string `json:"title"`
	Body string `json:"body"`
}

func read(ownerRepo string, id int) (*IssueData, error) {
	apiURL := fmt.Sprintf("https://api.github.com/repos/%s/issues/%d", ownerRepo, id)
	resp, err := http.Get(apiURL)
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		log.Fatal(err)
		return nil, err
	}

	var result *IssueData
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		resp.Body.Close()
		return nil, err
	}

	return result, nil
}

Happy coding!

Create github issue ticket with golang

Tue, 05 Dec 2017 22:43:45 +0000

Hi guys, today is day 14 out of 100 days of golang coding.

This time I was playing with github issues api and made small script which create new issues in given repository. However to use the code you would need to obtain github personal token key.

The interesting part was to make http post request with custom headers.

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

func main() {
	token := flag.String("token", "", "github auth token")
	repo := flag.String("repo", "", "github owner/repo e.g. golang/go")
	title := flag.String("title", "", "title for new issue")
	body := flag.String("body", "", "body for new issue")
	flag.Parse()

	if *token == "" || *title == "" || *repo == "" {
		log.Fatal("--token, --repo and --title parameters must be provided")
	}
	create(*repo, *title, *body, *token)
}

// NewIssue - specify data fields for new github issue submission
type NewIssue struct {
	Title string `json:"title"`
	Body string `json:"body"`
}

func create(ownerRepo, title, body, token string) {
	apiURL := "https://api.github.com/repos/" + ownerRepo + "/issues"
	//title is the only required field
	issueData := NewIssue{Title: title, Body: body}
	//make it json
	jsonData, _ := json.Marshal(issueData)
	//creating client to set custom headers for Authorization
	client := &http.Client{}
	req, _ := http.NewRequest("POST", apiURL, bytes.NewReader(jsonData))
	req.Header.Set("Authorization", "token "+token)
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusCreated {
		fmt.Printf("Response code is is %d\n", resp.StatusCode)
		body, _ := ioutil.ReadAll(resp.Body)
		//print body as it may contain hints in case of errors
		fmt.Println(string(body))
		log.Fatal(err)
	}
}

Example usage is as follow:

github issue tracker with categories by date in go

Mon, 04 Dec 2017 21:26:44 +0000

Hi guys, today is day 13 out of 100 days of code in go!

This time it is example of fetching issues from github and categorizing by created date. To run example you need to install github issue searcher package from The Go Progamming Language book

go get gopl.io/ch4/github

Full code

package main

import (
	"fmt"
	"log"
	"os"
	"time"

	"gopl.io/ch4/github"
)

func main() {
	result, err := github.SearchIssues(os.Args[1:])
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%d issues:\n", result.TotalCount)
	var dateformat string
	for _, item := range result.Items {
		days := int(time.Since(item.CreatedAt).Hours()) / 24
		if days < 30 {
			dateformat = "less than a month old"
		} else if days < 365 {
			dateformat = "less than a year old"
		} else {
			dateformat = "more than a year old"
		}
		fmt.Printf("%s, #%-5d %9.9s %.55s\n", dateformat, item.Number, item.User.Login, item.Title)
	}
}

Happy coding!

Sort map by it's keys in go

Sun, 03 Dec 2017 12:46:12 +0000

Hi guys, this is day 12 out of 100 days of code. I didn’t post for a while, because I did a small break for hackaton, but now I am back on track.

When you print a map using range function it will access elements in randomized order. So, if you want to print map in sorted order you have to sort keys first. See how:

package main

import (
	"fmt"
	"sort"
)

func main() {
	m := map[string]int{"A": 1, "B": 2, "AA": 1, "C": 3, "BBB": 2}

	//reverse keys and values of m map
	var mapKeys []string
	fmt.Print("Unsorted:\n")
	for k, v := range m {
		fmt.Printf("%s -> %d\n", k, v)
		mapKeys = append(mapKeys, k)
	}

	sort.Strings(mapKeys)
	fmt.Print("Sorted:\n")
	for _, v := range mapKeys {
		fmt.Printf("%s -> %d\n", v, m[v])
	}
}

Solution is to use additional array for keys and sort it in wished order.

how to sort map values in go

Mon, 27 Nov 2017 22:57:20 +0000

Hi guys, this is day 11 out of 100 days of go coding.

This time it is very short demo of go maps and simple sort by map values. Note that the example below will not work correctly if values has duplicates.

package main

import (
	"fmt"
	"sort"
)

func main() {
 //init a map with strings keys and int values
	var m = make(map[string]int)
	m["Sun"] = 7
	m["Sat"] = 6
	m["Fri"] = 5
	m["Thu"] = 4
	m["Mon"] = 1
	m["Tue"] = 2
	m["Wed"] = 3

	//reverse keys and values of m map
	var days = make(map[int]string)
	//array of indexes for sorting
	var daykeys = make([]int, len(m))

	fmt.Print("Unsorted days of week\n")
	counter := 0
	for k, v := range m {
		fmt.Printf("%s -> %d\n", k, v)
		days[v] = k
		daykeys[counter] = v
		counter++
	}
	//sort indexes array here
	sort.Ints(daykeys)

	fmt.Print("Sorted days of week\n")
	for _, v := range daykeys {
		fmt.Printf("%s\n", days[v])
	}
}

I believe this code has a lot of room for optimization, so if you know how please write me in comments or ping me in twitter with your version.

Example of using struct in go for beginners

Sun, 26 Nov 2017 14:34:15 +0000

Hi, this is day 9 out of 100 days of code in go.

Today I am playing with struct type. Struct is a go way to define custom types. Use it when standard types doesn’t suite you. Enough words, lets see code examples.

Classic example Employee type

// Employee - new type
type Employee struct {
	ID int
	Name string
	Manager *Employee //reference to itself
}

ID and Name fields is quite obvious. Manager field is the same type as struct itself, so it must be a reference type and in our business logic will point to Manager data.

Transparent HTTP proxy with filter by user agent using golang

Fri, 24 Nov 2017 00:55:08 +0000

This is day 10 out of 100 Days of golang coding!

Idea for today is to build transparent http proxy with ability to filter traffic. As for a filter I will use user agent which is common practice to filter traffic.

So, for the task I have used two go modules: user_agent and goproxy:

go get github.com/mssola/user_agent
go get gopkg.in/elazarl/goproxy.v1

First I have to setup a proxy and set a decide which hosts I want to match:

Count words frequency reading standard input with go

Wed, 22 Nov 2017 01:52:40 +0000

Hi guys, today is day 8 out of 100 days of code.

The task for today is to count words frequency reading data from stdin. Input is scanned using bufio *Scanner with a split by words(ScanWords). Lets see the code:

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	//map to store words frequency
	words := make(map[string]int)
	//we will read from file
	in := bufio.NewReader(os.Stdin)
	scanner := bufio.NewScanner(in)
	//we ask scanner to split input by words for us
	scanner.Split(bufio.ScanWords)
	count := 0
	//scan the inpurt
	for scanner.Scan() {
		//get input token - in our case a word and update it's frequence
		words[scanner.Text()]++
		count++
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "reading input:", err)
	}
	fmt.Printf("Total words: %d\n", count)
	fmt.Printf("Words frequency: \n")
	//todo: sort words by values for nice print
	for k, v := range words {
		fmt.Printf("%s:%d\n", k, v)
	}
}

Results are stored in a map words. The property of map that it doesn’t have defined order of keys, so the bonus here is to sort words map by frequency of words(by values).

Simple example of packages and imports in golang

Tue, 21 Nov 2017 00:22:55 +0000

This is day 7 out of 100 days of golang coding.

By requests of my friends this post is about packages, files and imports.

Packages in go is the same as modules and libraries in other languages. To make a package you need two decide two things: package path and package name.

In my example package name is helloworld and because it is day7 it is inside day7 folder. Full path looks like: github.com/vorozhko/go-tutor/day7/helloworld. Full path is calculated based on $GOPATH variable which is ~/go by default, but can be set to any other in .bashrc file.

very basic web crawler on golang

Fri, 17 Nov 2017 18:27:38 +0000

Hi guys,

this is day 6 out 100 days of code on go lang.

Following code implement recursive fetching of internal links on given web page.

What I want to do next is to add goroutines in action, because fetching process is nice to have run in parallel. Any suggestion how to do it?

package main

//todo:
// - every link must be visited only once [done]
// - keep a map of visited links [done]
// - fix links and page concatination [done]
// - extract domain from request uri to simplify crawling [done]
// - rework how internal links are selected for crawling
// - fix how crawling settings are set like depth and maxLinks

import (
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"time"

	"golang.org/x/net/html"
)

//hash of visited links to prevent double visit
var visitedLinks map[string]bool
var baseURL = flag.String("url", "", "start url")

func main() {
	visitedLinks = make(map[string]bool)
	flag.Parse()

	if *baseURL == "" {
		log.Fatal("--url paramters is required")
	}

	visitedLinks[*baseURL] = false

	//set parameters for crawling
	crawl("/")
}

func crawl(link string) {
	//check if link already visited
	if visitedLinks[link] {
		return
	}
	//set link as visited
	visitedLinks[link] = true
	fmt.Printf("Crawling %s ..................\n\n", *baseURL+link)
	resp, err := http.Get(*baseURL + link)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	linkCounter := 0
	for _, href := range getLinks(resp.Body) {
		//todo: rework how links are selected
		if len(href) > 0 && string(href[0]) == "/" && // only internal links
			href != link { //skip current page
			if len(href) > 1 && href[1] == '/' { //skip external links which start with //
				continue
			}
			linkCounter++
			//fmt.Printf("Found: %s\n", href)
			crawl(href)
			time.Sleep(time.Second * 1)
		}
	}
}

//Collect all links from response body and return it as an array of strings
func getLinks(body io.Reader) []string {
	var links []string
	z := html.NewTokenizer(body)
	for {
		tt := z.Next()

		switch tt {
		case html.ErrorToken:
			return links
		case html.StartTagToken, html.EndTagToken:
			token := z.Token()
			if "a" == token.Data {
				for _, attr := range token.Attr {
					if attr.Key == "href" {
						links = append(links, attr.Val)
					}

				}
			}

		}
	}
}

Source code on github

Get all links from html page with go lang

Thu, 16 Nov 2017 21:06:55 +0000

Hi guys, this is day 5 out of 100 days of code!

Today I have coded html href links parser. This is part of web crawler project about which I will post in following days.

package main

import (
	"io"
	"log"
	"net/http"
 "fmt"

	"golang.org/x/net/html"
)

func main() {
 resp, err := http.Get("https://golang.org/")
 if err != nil {
 log.Fatal(err)
 }
 for _, v := range getLinks(resp.Body) {
 fmt.Println(v)
 }
}

//Collect all links from response body and return it as an array of strings
func getLinks(body io.Reader) []string {
	var links []string
	z := html.NewTokenizer(body)
	for {
		tt := z.Next()

		switch tt {
		case html.ErrorToken:
			//todo: links list shoudn't contain duplicates
			return links
		case html.StartTagToken, html.EndTagToken:
			token := z.Token()
			if "a" == token.Data {
				for _, attr := range token.Attr {
					if attr.Key == "href" {
						links = append(links, attr.Val)
					}

				}
			}

		}
	}
}

checking current time with go lang channels

Wed, 15 Nov 2017 19:32:49 +0000

This is day 4 out of 100 days of code. Two code snippets today. First is very simple go channel. It get current system time and post it to a channel then on other end message retrieved out of the channel and printed.

package main

import (
	"fmt"
	"time"
)

func main() {
	messages := make(chan string)
	go func() {
		for {
			messages <- fmt.Sprintf("Time now %s\n", time.Now())
			time.Sleep(100 * time.Millisecond)
		}
	}()
	for {
		msg := <-messages
		fmt.Println(msg)
	}
}

Second code snippet is a program which check two strings for anagram. When one string is equal reverse of other it is anagram.

Recursive search through tree of files with golang

Tue, 14 Nov 2017 21:51:39 +0000

This is day 3 out of 100 days of code in go lang.

This code snippet does recursive search through directory tree. One improvement which can be made is to replace custom recursive function readFiles with filepath.Walk

Full code:

package main

import (
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"strings"
)

var path = flag.String("path", "", "file path to search in")
var search = flag.String("search", "", "search string to look for")

func main() {
	flag.Parse()
	fi, err := os.Stat(*path)
	if err != nil {
		log.Fatal(err)
	}
	//fix path if directory
	if fi.Mode().IsDir() {
		*path = strings.TrimRight(*path, "/") + "/"
		readFiles(*path, *search)
	} else {
		log.Fatal("path must be a directory, but file was provided: ", *path)
	}
}

func readFiles(path, search string) {
	files, err := ioutil.ReadDir(path)
	if err != nil {
		log.Fatal(err)
	}
	for _, file := range files {
		fullpath := path + file.Name()
		if file.Mode().IsDir() {
			readFiles(fullpath+"/", search)
		} else if file.Mode().IsRegular() {
			searchInFile(fullpath, search)
		}
	}
}

func searchInFile(fullpath, search string) {
	data, err := ioutil.ReadFile(fullpath)
	if err != nil {
		log.Fatal(err)
	}
	//need to check for file type to detect filter off non-text files
	fileType := http.DetectContentType(data)
	if strings.Index(fileType, "text") == -1 {
		//skip all non text files
		return
	}
	for _, line := range strings.Split(string(data), "\n") {
		if strings.Index(line, search) > -1 {
			fmt.Printf("%s: %s\n", fullpath, line)
		}
	}
}

Source code at Github

very simple grep tool in GO - search substring in files

Mon, 13 Nov 2017 18:53:02 +0000

Hi guys, here is day 2 of 100 days of code.

This time it is very simple implementation of grep tool. What it does it search string in specific directory and report matching lines. What have I learned is that strings.Index is very useful to work with text and http.DetectContentType was the way to detect binary files.

Full code:

package main

import (
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strings"
)

func main() {
	path := flag.String("path", "", "file path to search in")
	search := flag.String("search", "", "search string to look for")
	flag.Parse()

	files, err := ioutil.ReadDir(*path)
	if err != nil {
		log.Fatal(err)
	}
	for _, file := range files {
		if file.Mode().IsDir() {
			//to do: traverse directories recursively
			continue
		}
		data, err := ioutil.ReadFile(file.Name())
		if err != nil {
			log.Fatal(err)
		}
		//need to check for file type to detect binary content
		fileType := http.DetectContentType(data)
		for _, line := range strings.Split(string(data), "\n") {
			if strings.Index(line, *search) > -1 {
				if strings.Index(fileType, "text/plain") > -1 {
					fmt.Printf("%s: %s\n", file.Name(), line)
				} else {
					//best guess it is binary file
					//no need to go through all lines in binary file
					fmt.Printf("Binary file %s matches\n", file.Name())
					break
				}
			}
		}
	}
}

Source code at Github

Simple example of golang os.Args and flag module

Sun, 12 Nov 2017 15:44:40 +0000

Hi all, this is day 1 of 100 days I am coding one go program a day. Wish me good luck!

In this example I will show how to parse command line arguments with flag module and os.Args array.

Flag module is very powerful and can be as simple as this:

//...
import "flag"
//...
name := flag.String("user", "", "user name")
flag.Parse()
fmt.Printf("user name is %s\n", *name)

To have the “same” functionality with os.Args you have to do some work. In following example I added support for –user, -user and user=<value> arguments.

Continuous integration and deployment with Google Cloud Builder and Kubernetes

Sun, 20 Aug 2017 13:00:02 +0000

Pipeline of Continuous Integration(CI) for containers has several basic steps. Lets see what they are:

Setup a trigger

Listen to a change in repositories(github, bitbucket) such like pull request, new tag or new branch.

It is basic step for any CI/CD tool and for google cloud builder it is pretty trivial task to setup. Check out Container Registry - Build Triggers tool in google cloud console.

Build an image

When change to repository occur we want to start build of new Docker container image for a change. Good practice is to tag new image with branch name and git reference hash. E.g. master-00covfefe

Undocumented locust load API calls

Sun, 30 Jul 2017 15:05:27 +0000

Hey folks,

today I found that locust load do support API calls, so you can grab statistics and manage it’s execution.

If you like me hear about it first time here is few examples:

Start locust task

curl -XPOST $LOCUST_URL/swarm -d"locust_count=100&hatch_rate=10"

Get stats

curl $LOCUST_URL/stats/requests

Stop locust task

curl $LOCUST_URL/stop

All requests API endpoints can be found in locust source code on github

Another useful feature which is worth to mention is locust extension ability. Using it you can add your own routes to API

Prepare Application Launch Checklist

Sun, 13 Dec 2015 12:23:22 +0000

Introduction

Application Launch checklist is aimed for Devops, Sysops and anyone whois job to make website available and reliable. The checklist better works for applications which are going to be Live in near feature, but also useful to validate your Devops processes for already running applications.

This checklist is a complied notes from Launch Checklist for Google Cloud Platform. It is mostly targeted on Devops work routines and in a nutshell explain first and necessary Devops steps into launching applications.

Making simple Splunk Nginx dashboard

Wed, 09 Dec 2015 13:01:38 +0000

As a DevOps guy I often do incident analysis, post deployment monitoring and usual logs checks. If you also is using Splunk as me when let me show for you few effective Splunk commands for Nginx logs monitoring.

Extract fileds

To make commands works Nginx log fields have to be extracted into variables. Where are 2 ways to extract fields:

By default Splunk recognise “access_combined” log format which is default format for Nginx. If it is your case congratulations nothing to do for you!
For custom format of logs you will need to create regular expression. Splunk has built in user interface to extract fields or you can provide regular expression manually.

Site Reliability Engineer Blog

Projects & Open Source

Uses

Books I Read

How to recognize Great Work

1. Great Outcome (The “What”)

Bullet proofing Agentic Engineering

About

What I care about

Experience

2020 – present · McMakler

Improving Team Performance Measurement: A DORA and SLO/SLI Approach

DORA and SLO/SLI Practices

The Reality of Self-Hosting AI model for Code Suggestions

💸 The High Cost of the “Free” Model

Kubernetes operators quick start

Writing your own operator

Solving Top-K problem - Leaderboard in Python

What is Top-K problem?

Leader board requirements

Solution 1: using SQL database

LLM-Powered Unit Testing: Effortlessly Generate Domain Model Data

🚀 Supercharge Your Python Code Reviews: Automate with GPT and OpenAPI Endpoints

Tech Team Leaders' Guide to Strategy

Collecting Datadog APM traces using Grafana Alloy and Tempo

The Problem

Cost saving strategy for Kubernetes platform

Right-size infrastructure & use autoscaling

Kubernetes Nodes autoscaler

Multi provider DNS management with Terraform and Pulumi

The Problem

Grafana a new look

Big ecosystem of tools

Can ArgoCD replace Helm managers?

Why ArgoCD is replacing Helm managers?

Path to Staff Engineer role

Start working on Staff engineer package

Sharpen your soft skills

Learn Staff Engineer tools

Summary

Certified Kubernetes Administrator

Implementing RED method with Istio

RED or Rate Errors Duration

Brief Summary of Site Reliability Engineering best practices

Simple LRU cache implementation on Python 3

What is LRU Cache?

Problem

Solution

Filebeats configuration for Kubernetes

What’s so cool about above configuration

Filebeat Autodiscover

Integrating Flask with Jaeger tracing on Kuberentes

Flask

Code

Backup and restore of Etcd cluster

Etcd backup

Having fun with Kubernetes deployment

Install deployment

Install nginx 1.12.2 with 2 pods

How to check Kubernetes cluster health?

Install node problem detector

Multi node Kubernetes cluster on Vagrant

Build Kubernetes control plane image with Packer

Packer builders

Practical guide to Kubernetes Certified Administration exam

Covered topics so far are:

Share your efforts

Disaster recovery of single node Kubernetes control plane

Overview

Apiserver VM shutdown or apiserver crashing

Results

Mitigations

In case of apiserver crash

In case of VM shutdown

Thoughts on High available Kubernetes cluster with single control plane node

Why single node control plane?

Go http middleware chain with context package

Implementation

Middleware chain

How to enable minikube kvm2 driver on Ubuntu 18.04