Posts on Alan Zhan Blog

Building a Private GKE Cluster with Terraform

Sun, 12 Mar 2023 18:04:41 +0800

Let’s spend about ten minutes together — I’ll walk you through using Terraform to build a private GKE Cluster step by step!

Setting Up GCP

Create a Service Account

First, go to the Google Cloud console and create a Service Account for Terraform to use. Follow steps 1, 2, and 3 in the diagram above. If you already have a Service Account, you can skip this step.

Mindset: The New Psychology of Success

Sun, 02 Oct 2022 20:20:53 +0800

Mindset Types

Imagine you took a course that was very important to you and that you really enjoyed. Your professor announces the midterm results, and you only scored 60. You’re very disappointed. That evening when you’re heading home, you discover you missed the last train and have to walk home. Feeling angry, you call your best friend to vent, but they don’t pick up.

How would you think about this story?

Kubernetes Core Component: Kubelet

Tue, 30 Aug 2022 20:56:08 +0800

Kubelet Architecture

As shown in the kubelet internal component structure diagram below, Kubelet is composed of many internal components:

Kubelet API: Including the authenticated API on port 10250, cAdvisor API on port 4194, read-only API on port 10255, and health check API on port 10248.
syncLoop: Receives Pod updates from the API or manifest directories, sends them to podWorkers for processing, extensively using channels for async request handling.
Auxiliary managers: Such as cAdvisor, PLEG, Volume Manager, etc., handling work outside of syncLoop.
CRI: Container Runtime Interface, responsible for communicating with container runtime shims.
Container runtimes: Such as dockershim, rkt, etc.
Network plugins: Currently supports CNI and kubenet.

Plain English Leetcode - 25 Reverse Nodes in k-Group

Sun, 28 Aug 2022 14:22:55 +0800

25. Reverse Nodes in k-Group

https://leetcode.com/problems/reverse-nodes-in-k-group/

Hard

Given the head of a linked list, reverse the nodes of the list k at a time, and return the modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should remain as it is.

You may not alter the values in the list's nodes, only nodes themselves may be changed.

The Forrest Gump Investment Method

Sun, 14 Aug 2022 14:41:06 +0800

I remember about three years ago, when I was a complete stock market beginner. Right after learning about the Taiwan stock market, I jumped straight into trading. My first stock was CTBC Financial Holdings (2891) — I still remember the ticker clearly. But watching the daily ups and downs was nerve-wracking, and I eventually couldn’t take it anymore and sold. Fortunately, I made a tiny profit — enough for a lunch box — rather than losing money. That was lucky indeed. Then, by chance, I came across “The Forrest Gump Investment Method,” which launched my journey into index investing. Today, I’d like to introduce this book.

Kubernetes Core Component: Controller Manager

Sat, 30 Jul 2022 20:07:01 +0800

Controller Manager is the automation control center of a Kubernetes cluster, containing over 30 controllers that manage Pod-related, network-related, storage-related operations, and more. Most controllers work similarly — each controller is a control loop responsible for watching its corresponding resources through the API server, deciding on the next action based on the object’s state, and driving it toward the desired state.

Controller Manager is the brain of the cluster and the key to keeping it running.
Its role is to ensure Kubernetes follows the declarative system specification, keeping the system’s Actual State consistent with the user-defined Desired State.
Controller Manager is a combination of multiple controllers. Each controller is a control loop responsible for watching its managed objects and completing configuration when objects change.
Failed controller configurations typically trigger automatic retries. Through the controller’s continuous retry mechanism, the entire cluster ensures Eventual Consistency.

Controller Workflow

Plain English Leetcode - 70 Climbing Stairs

Wed, 13 Jul 2022 22:22:58 +0800

70. Climbing Stairs

https://leetcode.com/problems/climbing-stairs/

Easy

You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Example 1:

Input: n = 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Example 2:

Input: n = 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

Kubernetes - Node Maintenance and Pod Migration

Sun, 10 Jul 2022 18:19:11 +0800

Our company recently discovered machines on GKE with particularly low resource utilization. Those unused resources are still costing money, so we created a new Node Pool with lower and cheaper resources, then used Cordon + Drain (or manually deleted Pods) to reschedule Pods onto the new Node Pool. On GKE, simply deleting the old Node Pool would achieve the same result, but we chose the safer approach.

This essentially marks a Node as unschedulable, then lets Pods migrate to the expected hosts. Let’s discuss how to safely handle node failures or upgrades.

Plain English Leetcode - 69 Sqrt(x)

Thu, 30 Jun 2022 23:37:48 +0800

69. Sqrt(x)

https://leetcode.com/problems/sqrtx/

Easy

Given a non-negative integer x, compute and return the square root of x.

Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.

Note: You are not allowed to use any built-in exponent function or operator, such as pow(x, 0.5) or x ** 0.5.

Example 1:

Input: x = 4
Output: 2

Example 2:

Input: x = 8
Output: 2
Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.

Plain English Leetcode - 433 Minimum Genetic Mutation

Tue, 28 Jun 2022 23:55:43 +0800

433. Minimum Genetic Mutation

https://leetcode.com/problems/minimum-genetic-mutation/

Medium

A gene string can be represented by an 8-character long string, with choices from 'A', 'C', 'G', and 'T'.

Suppose we need to investigate a mutation from a gene string start to a gene string end where one mutation is defined as one single character changed in the gene string.

For example, "AACCGGTT" --> "AACCGGTA" is one mutation.

There is also a gene bank bank that records all the valid gene mutations. A gene must be in bank to make it a valid gene string.

Plain English Leetcode - 23 Merge k Sorted Lists

Sat, 25 Jun 2022 23:29:46 +0800

23. Merge k Sorted Lists

https://leetcode.com/problems/merge-k-sorted-lists/

Hard

You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.

Merge all the linked-lists into one sorted linked-list and return it.

Example 1:

Input: lists = [[1,4,5],[1,3,4],[2,6]]
Output: [1,1,2,3,4,4,5,6]
Explanation: The linked-lists are:
[
  1->4->5,
  1->3->4,
  2->6
]
merging them into one sorted list:
1->1->2->3->4->4->5->6

Example 2:

Input: lists = []
Output: []

Example 3:

Input: lists = [[]]
Output: []

Plain English Leetcode - 200 Number of Islands

Thu, 23 Jun 2022 23:50:13 +0800

200. Number of Islands

https://leetcode.com/problems/number-of-islands/

Medium

Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.

An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

Input: grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
Output: 1

Example 2:

Plain English Leetcode - 78 Subsets

Mon, 20 Jun 2022 18:00:00 +0800

78. Subsets

https://leetcode.com/problems/subsets/

Medium

Given an integer array nums of unique elements, return all possible subsets (the power set).

The solution set must not contain duplicate subsets. Return the solution in any order.

Example 1:

Input: nums = [1,2,3]
Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

Example 2:

Input: nums = [0]
Output: [[],[0]]

Constraints:

1 <= nums.length <= 10
-10 <= nums[i] <= 10
All the numbers of nums are unique.

Problem

Given a numeric array, return all possible combinations of its elements.

Plain English Leetcode - 111 Minimum Depth of Binary Tree

Thu, 16 Jun 2022 18:00:00 +0800

111. Minimum Depth of Binary Tree

https://leetcode.com/problems/minimum-depth-of-binary-tree/

Easy

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Note: A leaf is a node with no children.

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: 2

Example 2:

Input: root = [2,null,3,null,4,null,5,null,6]
Output: 5

Constraints:

The number of nodes in the tree is in the range [0, 10⁵].
-1000 <= Node.val <= 1000

Problem

Find the shallowest leaf node in the tree — what is its depth?

Plain English Leetcode - 104 Maximum Depth of Binary Tree

Tue, 14 Jun 2022 18:00:00 +0800

104. Maximum Depth of Binary Tree

https://leetcode.com/problems/maximum-depth-of-binary-tree/

Easy

Given the root of a binary tree, return its maximum depth.

A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: 3

Example 2:

Input: root = [1,null,2]
Output: 2

Constraints:

The number of nodes in the tree is in the range [0, 10⁴].
-100 <= Node.val <= 100

Problem

Find the deepest node in the tree — what is its depth?

How to Survive in a Winner-Take-All Workplace

Mon, 13 Jun 2022 18:00:00 +0800

“Winner takes all” — the meaning is pretty clear from the phrase itself, and it happens constantly in our lives. Here’s a simple example: in a democratic society, there’s a presidential election every few years. Only the candidate with the most votes wins and becomes the next president — second and third place seem far less important. In romance, every man can pursue their dream partner, but ultimately only one wins. On the sports field, in companies, everywhere — most scenarios are winner-take-all.

Plain English Leetcode - 226 Invert Binary Tree

Sun, 12 Jun 2022 13:01:44 +0800

226. Invert Binary Tree

https://leetcode.com/problems/invert-binary-tree/

Easy

Given the root of a binary tree, invert the tree, and return its root.

Example 1:

Input: root = [4,2,7,1,3,6,9]
Output: [4,7,2,9,6,3,1]

Example 2:

Input: root = [2,1,3]
Output: [2,3,1]

Example 3:

Input: root = []
Output: []

Constraints:

The number of nodes in the tree is in the range [0, 100].
-100 <= Node.val <= 100

Problem

Swap all left and right nodes of the entire tree.

Kubernetes Core Component: Scheduler

Mon, 16 May 2022 22:40:48 +0800

Strictly speaking, the Scheduler is a special type of Controller — its working principle is no different from other controllers.

The Scheduler’s special responsibility is to monitor all unscheduled Pods in the cluster and obtain the health status and resource usage of all nodes, selecting the best node for each pending Pod to complete scheduling.

kube-scheduler is responsible for assigning and scheduling Pods to nodes within the cluster. It watches kube-apiserver for Pods that haven’t been assigned to a Node, then assigns nodes to these Pods based on scheduling policies (by updating the Pod’s NodeName field).

Kubernetes Core Component: API Server

Sun, 24 Apr 2022 19:07:12 +0800

API Server

kube-apiserver is one of the most important core components of Kubernetes, providing the following key features:

Cluster management REST API, including authentication, authorization, data validation, and cluster state changes
- Authentication
- Authorization
- Admission (Mutating & Validating)
Acts as the data exchange and communication hub between other modules. Other modules can only query or modify data through the API Server — only the API Server can directly operate on etcd.

kube-apiserver supports HTTPS (default port 6443) and HTTP API (default listening on 127.0.0.1:8080). The HTTP API is insecure with no authentication or authorization mechanism — it’s not recommended for production environments.

MongoDB Index Best Practices

Sun, 10 Apr 2022 16:19:10 +0800

After the sorted operation OOM incident in production from the previous post, I realized my understanding of MongoDB indexes wasn’t as deep as it should be. I started searching extensively and finally organized some key points. Some were covered in the previous post — feel free to review MongoDB Sorted Operation OOM.

When to Use Indexes

When you have sorting scenarios and in-memory sorting exceeds 32 MB.
When a specific field has a uniqueness requirement.
When the document count is large.
Build indexes on high-cardinality fields.

When NOT to Use Indexes

When an index cannot effectively filter data.
Don’t set indexes on frequently updated fields.

How to Design and Use Indexes

Use Compound Indexes Instead of Single Field Indexes

In MongoDB, a find query can only use one index at a time (in most scenarios). So if your use case frequently filters on multiple fields, use a Compound Index composed of multiple fields to match your query conditions.

MongoDB Sorted Operation OOM

Sun, 20 Mar 2022 15:11:15 +0800

This is a rare case where I learned by working backward from a problem — I’d better document it well. Recently, our production environment hit a MongoDB sort operation limit with this specific error:

MongoDB.Driver.MongoCommandException: Command find failed: Encountered non-retryable error during query :: caused by :: Executor error during find command :: caused by :: Sort operation used more than the maximum 33554432 bytes of RAM.

Well, the problem has occurred. Let’s solve it first — so we added an index as an immediate fix. But what exactly is a MongoDB index?

Kubernetes Core Component: etcd

Mon, 28 Feb 2022 15:58:47 +0800

In any system, what is the most important thing? The answer is simple: data. So I’m starting my deep dive with Kubernetes’ database — etcd!

What is etcd?

etcd is a distributed key-value store developed by CoreOS based on the Raft algorithm. It can be used for service discovery, shared configuration, and consistency guarantees (such as database leader election, distributed locks, etc.).

In distributed systems, managing state across nodes has always been challenging. etcd is designed specifically for service discovery and registration in cluster environments. It provides features like data TTL expiration, data change monitoring, multi-value operations, directory watching, distributed lock atomic operations, and more — making it easy to track and manage cluster node states.

Installing Kubernetes with Kubeadm - Twice

Sun, 20 Feb 2022 15:04:19 +0800

To better understand K8s through hands-on practice, I wanted to set up a K8s cluster myself. There are increasingly many ways to self-host K8s nowadays — minikube, Kubeadm, and more. I decided to go with Kubeadm, but the installation wasn’t exactly smooth. This post shares the problems I encountered and how I solved them.

First Installation of Kubeadm

Install Ubuntu.
Install Docker.
1. Modify Docker’s cgroup settings to ensure the K8s and container runtime cgroup drivers match, preventing system instability.
```
sudo vim /etc/docker/daemon.json
```
```
{
    "exec-opts": ["native.cgroupdriver=systemd"]
}
```
2. Restart Docker
```
sudo systemctl restart docker
```

Install Kubeadm.

Allow iptables to inspect bridged traffic.

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sudo sysctl --system

Update apt and install packages required by K8s.

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl

Download the Google Cloud public signing key.

sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg

Add the K8s apt repository.

echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Update the apt package index, install kubelet, kubeadm, and kubectl, and pin their versions.

sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

Initialize K8s.
```
sudo kubeadm init
```

Join worker nodes

sudo kubeadm join 192.168.83.130:6443 --token token....  --discovery-token-ca-cert-hash sha256:......................

Copy kubeconfig

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

K8s Nodes Not Ready

I finally got it installed! So I added the worker nodes to the cluster. After joining, just as I was about to start using K8s, I noticed all nodes were in NotReady status.

Kubernetes Fundamentals

Mon, 14 Feb 2022 21:48:40 +0800

It’s finally time to dive deep into Kubernetes. Since Kubernetes is built with Go, I’ve already done some in-depth research on Go beforehand. I won’t be covering Docker and container technology here since I’ve already studied those extensively. If you’d like to see that content, let me know! From here on, I’ll be writing a series of articles focused on Kubernetes.

Kubernetes

What is Kubernetes (K8s)? K8s is the abbreviation for Kubernetes — because there are eight letters between “K” and “s.” It’s Google’s open-source container cluster management system, the open-source version of Google’s years of large-scale container management technology called Borg. Its main features include:

Golang Memory Management and GC In-Depth Analysis

Sun, 13 Feb 2022 14:42:09 +0800

A new year has arrived! After completing the analysis of Golang Goroutine and GMP Model In-Depth Analysis, I gained a much more comprehensive understanding of the Go language. But after learning about GMP, aren’t we still missing the memory management aspect? So today, let’s dive deep into how Go manages its memory.

The Memory Management Debate

When it comes to memory management, there’s been a long-standing debate: who should manage memory — the machine or the developer? Whether it’s machine-managed or human-managed, everyone agrees that memory management is critically important, but opinions diverge:

Golang Goroutine and GMP Model In-Depth Analysis

Mon, 24 Jan 2022 20:24:58 +0800

I’ve been studying Kubernetes recently, so I need to become good friends with the Go language. While reading, I came across goroutines, but couldn’t fully understand where they came from and why they exist. So before we dive deep into goroutines, we should first learn some history — this will give us a more comprehensive understanding of the principles and design philosophy behind goroutines.

The Origin of Golang’s Scheduler

The Single-Process Era

We know that software runs on top of the operating system, and the CPU does the actual computation. In early operating systems, each program was a process, and the next process could only run after the current one finished.

10 Dockerfile Best Practices

Sun, 16 Jan 2022 16:55:15 +0800

I was recently organizing Docker knowledge for myself and came across Dockerfile best practices. I planned to summarize them, but then I found that the official documentation already has best practices, so I decided to translate them and add my own insights.

Containers Should Be Ephemeral

Containers built from a Dockerfile should be as ephemeral as possible. “Ephemeral” here means they can be started quickly and stopped quickly.

Understand the Build Context

Including files that aren’t needed to build the image results in a larger build context and larger image. This increases build time, pull/push time, and the runtime size of the container.

GitHub Pages Custom Domain Setup

Sun, 09 Jan 2022 14:58:58 +0800

I recently switched my domain name, so I decided to take some notes to help everyone easily set up their own GitHub Pages custom domain.

Step 1: Purchase a Domain

First, purchase the domain name you want. I bought mine from Google Domains. If you have a preferred domain registrar, feel free to use that. This guide uses Google Domains as an example.

Step 2: Add a CNAME Record in DNS Settings

After purchasing the domain, you need to configure the DNS settings. Follow the diagram below to set things up.

Interpolation Search Algorithm

Tue, 13 Jul 2021 21:51:30 +0800

Continuing with the number guessing game — for numbers 1 to 100, if you already know the result, using binary search might not be the most efficient approach. So what method should we use instead?

Concept

Interpolation Search: This is an algorithm based on binary search. The list being searched must be sorted beforehand, and the data distribution should ideally be linear. If the data is not linearly distributed, the search may result in O(n) performance, which could be even slower than binary search.

Jump Search Algorithm

Sun, 11 Jul 2021 14:48:35 +0800

Continuing with the number guessing game — can we try a different approach for numbers 1 to 100?

If we start from the beginning and jump forward by 10 each time we don’t guess correctly, we keep going until the maximum value in our range becomes less than or equal to our guess, then we search backward to find the exact value. This approach can be more efficient when the target value is relatively small.

Binary Search Algorithm

Sat, 10 Jul 2021 22:57:37 +0800

Let’s play a number guessing game. Pick an integer between 1 and 100 — you have to guess the number in my head, and you must do it in the fewest guesses possible. How would you approach it?

The answer is simple: you’d start by guessing 50. If it’s wrong and too high, you’d guess 25 next. If too low, you’d guess 75. And so on — each time you split the remaining range in half. What you’re using is essentially Binary Search.

Linear Search Algorithm

Sat, 10 Jul 2021 18:50:40 +0800

When checking whether an element exists, what is the most common approach? The answer is a for or while loop. Congratulations — you’ve already learned Linear Search!

Concept

Linear Search: This algorithm visits every element to check where the element is located in the array. If the element is not found, it returns -1.

Complexity

Time complexity: O(n)
Space complexity: O(1)

Examples

Go

package main

import "fmt"

func linearSearch(list []int, target int) int {
    for i := 0; i < len(list); i++ {
        if list[i] == target {
            return i
        }
    }
    return -1
}

func main() {
    fmt.Println(linearSearch([]int{1, 2, 3, 4, 5}, 3)) // 2
    fmt.Println(linearSearch([]int{1, 2, 3, 4, 5}, 6)) // -1
}

C#

class Algorithm
{
    public static int linearSearch(int[] list, int target)
    {
        for (var i = 0; i < list.Length; i++)
        {
            if (list[i] == target)
            {
                return i;
            }
        }

        return -1;
    }

    public static void Main(String[] args)
    {
        Console.WriteLine(linearSearch(new int[] {1, 2, 3, 4, 5}, 3)); // 2
        Console.WriteLine(linearSearch(new int[] {1, 2, 3, 4, 5}, 6)); // -1
    }
}

Feel free to leave a comment on my blog. Your feedback motivates me to keep writing. Thank you for reading, and let’s grow together to become better versions of ourselves.

Divide and Conquer

Wed, 07 Jul 2021 23:56:34 +0800

Divide and Conquer

As the name suggests, this approach breaks a complex problem into two or more identical or similar subproblems, solves the smaller problems, and then combines the results to produce the final answer.

Advantages

Reduces the difficulty of solving the problem.
Can improve execution efficiency.
In some cases, enables parallel processing to boost performance.

Steps

Divide: Break the problem into several smaller subproblems that are relatively independent and share the same form as the original problem.
Conquer: If the subproblem is small enough and easy to solve, solve it directly. Otherwise, solve the subproblems recursively.
Combine: Merge the solutions of the subproblems into the solution for the original problem.

Resources:

Big O Notation

Tue, 06 Jul 2021 23:56:58 +0800

How to Choose an Algorithm to Solve a Problem

The same problem can be solved using different algorithms, but which one is the best? There are two metrics for evaluating an algorithm:

Time complexity (time consumed)
Space complexity (memory consumed)

Generally, the less time and memory an algorithm uses, the better it is. Time complexity analysis can be further broken down into three cases:

Best case: Considers the minimum number of steps the algorithm needs to execute.
Worst case: Considers the maximum number of steps the algorithm needs to execute.
Average case: Considers the average number of steps the algorithm needs to execute.

Big O Notation as a Measurement Standard

Typically, we focus on finding the worst case, and we usually use Big O notation — a method for evaluating algorithm efficiency that represents execution speed and typically indicates the worst-case execution time.

Emotional Blackmail

Sat, 26 Jun 2021 18:46:52 +0800

What Is Emotional Blackmail?

Before discussing emotional blackmail, we need to understand what it actually is.

Emotional blackmailers may consciously or unconsciously use demands, threats, pressure, silence, and other direct or indirect means of blackmail to cause negative emotions in the victim — such as frustration, guilt, fear, and so on. These feelings then ferment and cause harm within the victim.

To reduce these uncomfortable feelings, the victim may comply with the blackmailer’s demands. Over time, this forms a vicious cycle where the victim allows the blackmailer to control them through these tactics, losing the freedom and ability to make their own decisions. Eventually, the victim’s sense of self is completely depleted in the process.

Atomic Habits

Sun, 13 Jun 2021 23:45:21 +0800

Compound Interest

The word “compound interest” runs throughout this entire book. We can say it is the eighth wonder of the world, and that would be no exaggeration.

If you improve by just 1% every day for a year (1.01 ^ 365 = 37.78), you will become 37 times better.
If you decline by 1% every day for a year (0.99 ^ 365 = 0.03), you will decline to nearly zero.

So habits are the compound interest of self-improvement.