作業系統

這一區塊主要解釋跟作業系統層面相關的名詞

簡稱 OS | 作業系統 | 就是電腦的作業系統，是三大作業系統分別是：Linux、Windows、macOS | | Linux | | 自由和開放原始碼的 UNIX-like 作業系統，是目前全世界佔比最高的作業系統，主要是使用於電腦伺服器和軟體開發上。對於一般消費大眾較不常見，但其實平常使用的線上等服務都是使用此作業系統。 | | Kernel | 核心 | 可以想像是作業系統的大腦，是處理所有事物中的核心程式 | | Shell | | OS 的操作介面，為作業系統解譯程式傳入需要處理的指令，來管理您與作業系統之間的互動。 | | Terminal | 終端機 | 是一台電腦或者計算機系統，用來讓用戶輸入數據，及顯示其計算結果的機器，簡而言之就是人類使用者與計算機互動的裝置 | | Open source | 開放原始碼 | 一種開放分享程式碼的文化，需要注意的是開放分享不意味著免費喔。依照不同的開放授權，有些也只允許使用在非營利的情況。 |

程式語言

SDK | 軟體開發套件 | 可以想像就是英雄套裝，當你需要變成鋼鐵人，你就下載這個 SDK 來使用你就使用鋼鐵裝。你想變成雷神索爾，你下載相對應的 SDK 就可以索爾。 | | Application programming interface
API | 應用程式介面 | 可以想像就是皮卡丘，你叫皮卡丘使用十萬伏特，他就會使用十萬伏特。 | | Integrated Development Environment
IDE | 整合開發環境 | 一種輔助程式開發人員開發軟體的應用軟體 | | Version control | 版本控制 | 目前主流常見的版本控制工具是 Git，所謂的版本控制就是控制每次的程式語言版本。因為每次不可能記住每次夕改程式語言時改了什麼，所以就利用版本控制工具來紀錄每次的修改。 | | Frontend | 前端 | 通常指的是使用者可以看到的範圍，例如網站介面、行動裝置介面（但行動裝置通常會稱作 Mobile 端） | | Backend | 後端 | 使用者看不到的範圍，例如伺服器、資料庫等 |

Library 和 Framework 的概念比較需要拉出來解釋，很常會搞混。Library 是類似 SDK 的東西，通常是包裝了許多常用的功能。但是使用後並不影響既有的程式架構。Framework 也是包裝了許多的功能，但是如果要使用的話，就必須按照它規定的規則來使用。

有點像是 Library 是自由重量的啞鈴，你可以用啞鈴做到很多種不同的運動來訓練不同的身體部位。但是 Framework 就像是機械式器材，你就是只能照他的使用方式來訓練特定的部位。

生態圈

環境前置步驟

1. 還原 MacBook Pro 至全新環境 macOS（全部資料刪除）

2. 設定好初始設定後，登入 Apple ID 進入 App Store 確定 macOS 版本和預設 APP 都更新到最新 macOS 版本

3. 到系統設定調整所有設定至個人習慣的設定

   • 三指拖移

   • 觸控板手勢開啟

   • 防火牆開啟

   • 輸入法設定

4. 安裝 Safari Extension 和設定開啟開發者清單

5. 到 App Store 安裝 XCode，安裝完後開啟 XCode 安裝 Command Line Tool

軟體安裝

分不同的類別，順序不影響

字體 Font

• 英文

  • Meslo Nerd Font for p10k

  • Fira Code for VSCode

  • JetBrains Mono

  • Cascadia Code

  • Sana Forgetica

• 中文

  • justfont 粉圓體

一般用途

• App Store：Magnet - 視窗管理

• App Store：The Unarchiver - 解壓縮工具

• 1Password - 密碼管理工具

• Bitdefender - 防毒軟體

• CleanMyMacX - 空間清理

• Bartender - Menu bar 管理工具

• CheatSheet - 快捷鍵查詢

• Raycast - 免費的 Spotlight 加強版

• MacGPT - 串接 ChatGPT

• Rewind - 個人操作記錄

• Chrome

• Edge

• TradingView

• ClickUp

• Rize - 個人時間追蹤軟體

文書

• Notion

• Miro

• Grammarly

• Dash

• Anki

• Airtable

• App Store：Day One

• App Store：Feedly

• App Store：OneNote

• App Store：Habitify

• App Store：GoodNotes

通訊

• App Store：Line

• App Store：Slack

• App Store：Twitter

• Discord

• Zoom

影音

• App Store：Shazam

• App Store：Noizio - 白噪音

• App Store：Motion

• App Store：Final Cut Pro

• App Store：Logic Pro

• App Store：MainStage

• App Store：Compressor

• Steam

• OBS

• Spotify

• VLC

開發工具

• iTerm2

• Wrap

• Termius

• Docker

• GPG Keychain

• Fig

• Visual Studio Code

• Cursor

• Lens

• Android Studio

• RapidAPI / Postman

• GitKraken

• Responsively

• Wireshark

• Figma

• TablePlus

• pgAdmin

• Querious

• RedisInsight

環境設定

iTerm2 設定

1. 到 iterm2 color theme 設定：Tomorrow Night Eighties

2. 匯入 Profile 設定檔

Zsh Shell 設定

1. 安裝 Homebrew

2. 安裝 rvm 並更新 ruby 到最新版本

3. 開啟 Fig，登入帳號後同步環境設定和 Plugins

   1. oh-my-zsh

   2. zsh-syntax-highlight

   3. zsh-autosuggestions

   4. Powerlevel10k

   5. Git Flow Completion

   6. Kube Color

   7. Zsh Completions

   8. Git Flow

4. 設定 Fig Aliases systemupdate = sudo gem update --system && sudo gem update && brew update && brew upgrade && omz update && rustup update && kubectl krew update && kubectl krew upgrade && gcloud components update && brew doctor

5. 開啟 iTerm2 執行 p10k configure 設定或是設定檔放置 ~/.p10k.zsh

6. 設定 gpg 和 git 全域設定

    gpg --full-generate-key
    gpg --list-secret-keys --keyid-format LONG
    gpg --armor --export <ID>
    git config --global user.name <Name>
    git config --global user.email <Email>
    git config --global commit.gpgsign true
    git config --global gpg.program /usr/local/bin/gpg
    git config --global user.signingkey <ID>
   

安裝 Command Line

General

# General
fig install --dotfiles
brew install --cask 1password/tap/1password-cli
brew install mycli pgcli jq yq tmux tldr shellcheck glances sonarqube hadolint \
  k6 slack-cli streamlink tree ffmpeg postgresql

# GitHub
brew install gh
gh auth login

# GitLab
brew install glab
glab auth login

# CloudFlare
brew install cloudflared

# Ngrok
brew install ngrok
ngrok config add-authtoken <Token>

# Shopify
brew tap shopify/shopify
brew install 
shopify login

# Ytarhcive
brew install danirukun/ytarchive/ytarchive
ytarchive --write-thumbnail -t --merge --add-metadata <URL> best

brew install go
brew install terraform terragrunt terraform-docs
brew install swift-format

Cloud Service

# gcloud
curl https://sdk.cloud.google.com | zsh
gcloud init

# firebase
curl -sL https://firebase.tools | upgrade=true zsh
firebase login:ci

# awscli
brew install awscli session-manager-plugin cdk8s cdktf
brew tap weaveworks/tap
brew install weaveworks/tap/eksctl
brew install aws/tap/copilot-cli
aws configure
aws configure set region ap-northeast-1
npm install -g aws-cdk

# azure cli
brew install azure-cli
az login

Kubernetes

# 快速切換 K8S Cluster 和 Namespace 的工具
brew install kubectx kustomize k9s skaffold helm helmfile 

# Kubernetes Operations
brew install kops
# SDK for building Kubernetes applications
brew install operator-sdk
# A tool for exploring each layer in a docker image
brew install dive
# The lazier way to manage everything docker
brew install lazydocker
# Container Image Linter for Security
brew install goodwithtech/r/dockle

brew tap kubeshark/kubeshark
brew install kubeshark

# Helm plugin
helm plugin install https://github.com/jkroepke/helm-secrets
helm plugin install https://github.com/databus23/helm-diff

krew

1. Install Krew

2. 在 Fig 設定 PATH 中加上 ${KREW_ROOT:-$HOME/.krew}/bin

# Show an RBAC access matrix for server resources
kubectl krew install access-matrix

# Manage cert-manager resources inside your cluster
kubectl krew install cert-manager

# Provides an overview of resource requests, limits, and utilization
kubectl krew install resource-capacity

# Kubernetes static code analysis
kubectl krew install score

# Show a tree of object hierarchies through ownerReferences
kubectl krew install tree

# Trace Kubernetes pods and nodes with system tools
kubectl krew install trace

Python

brew install python@3.11
ln -s -f /usr/local/bin/python3 /usr/local/bin/python
brew install pipenv poetry

Node.js

1. 安裝 nvm

nvm install-latest-npm

# General Tool
brew install watchman
npm i -g @vue/cli @angular/cli npm-check-updates vercel

# GitHub copilot
npm install -g @githubnext/github-copilot-cli
github-copilot-cli auth
# 在 Fig scripts 加上 eval "$(github-copilot-cli alias -- "$0")"

Rust

# rustup, rust version manager
brew install rustup
# curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# source $HOME/.cargo/env
# WASM
cargo install wasm-pack

Java

brew install openjdk
sudo ln -sfn /opt/homebrew/opt/openjdk/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk.jdk

Fig PATH 加上 /opt/homebrew/opt/openjdk/bin

嘗試和改進

幾個嘗試改變的調整

1. 導入 1Password 來做 SSH agent 的管理

   • 缺陷：目前遇到開啟 VSCode 有些套件要存取 KeyChain 或是 SSH 都需要做授權的問題

2. 使用 Fig 來做環境設定和同步

   • 缺陷：沒有辦法很好的管理已經現有的環境，然後一些安裝的 Script 會直接幫忙寫入 ENV 或 Script 到 .zshrc 中，但現在變成都還要自己手動加入到 Fig 中

3. 使用 Raycast 來加強和自動化個人的工作流程

   • 改進：功能很強大，但還在熟悉中

4. 嘗試使用 Cursor 來做開發工具

   • 基底看起來是包了 VSCode，但是 Extension 不多。看起來不會掃描既有專案的 Code Base，要使用在現有專案有點難。

5. 嘗試 Wrap & Termius & GitHub Copilot CLI

   • Wrap 提供的 Wrap AI 滿不錯的搭配 GitHub Copilot CLI 相當好用

   • Termius 可以用於平板做 AWS SSH 的登入操作也相當不錯用，對於突然要進機器處理問題，但又沒有帶筆電時相當好用的工具

6. 使用 Rewind & ClickUp & Rize & MacGPT

   • Rewind 可以搜尋和記錄自己過去筆電的所有操作，還能對於關鍵字做搜尋相當不錯，但是小心自己看什麼色色的東西也被記錄喔。

   • ClickUp 使用這個平台做自己的個人進度追蹤軟體，算是免費版裡面覺得功能最多，且跨平台。Jira 速度太慢了，受不了所以找了這個。

   • Rize 可以做個人的時間追蹤，想使用這個軟體來分析自己的生產力。缺點是目前只支援 Mac，還沒辦法跨平台到 iPad 或 iPhone。

   • MacGPT 直接在 Mac 上不用開網頁就能跟 ChatGPT 做對話的工具

我就比較沒有想要馬上出來評論一下，我喜歡讓子彈飛一會兒。跟討論一下我自己比較在意的討論點。

Google 為什麼慢了?

結論：因為他需要更小心

很多人說 Google 怎麼被微軟搶先了一步。剛開始 Bing 說要加上 AI 的時候大家都在說 Google 怎麼慢了。我就馬上跑去看 OpenAI 的網站，靠北呀啊就 Azure 贊助的。那當然在正式上線 ChatGPT 前，微軟早就在準備了。只能說就是一個準備好的連續技給 Google 一拳。不過 Google 也不愧是技術能量很強，也是趕出了一個 Brand（雖然跟 ChatGPT 還是有段距離）。但我相信以 Google 的資料量要趕上應該是不難，所以才可以看出微軟是準備了好幾層的連續技，想要一次拉開差距先來個 BingAI 再來個 Microsoft 365 再來 GitHub Copilot X。

所以為什麼覺得 Google 慢了，因為微軟是準備了一連串的連續攻勢。再來是因為 Google 重心我相信比較煩惱的是之後的 Cookieless 和隱私問題。（想想美國大選就知道 Facebok和 Google 被釘得多慘，沒有做社群的微軟算賺到？）。而且真的說要慢，那位 Apple 老大哥才慢呢。

Google 會被取代嗎？

結論：想太多了，打打嘴炮而已。

一個大型企業的收入不會是一個而已，雖然廣告是 Google 最大宗的收入，但是平台是難以取代的。Tiktok 出來了，一堆人說 Facebook 要完蛋了，喊了多久。結果？別忘了 YouTube、Google Maps、Google Cloud Platform、Chromebook 等。小公司就算了，當年一堆人說 IBM 要倒了，還不是到現在都活著。

許多人的工作要被取代？

結論：對也不對

我相信一些工作將要漸漸被取代，但絕對不會快。而且相對的會產生一些新的工作。舉個例子就是當年的國道收費員退休。收費員的工作被機器取代，相對的會產生需要維修機器和安裝的工作產生。只是當初被取代工作的人並不一定是同一批人能直接承擔新產生的工作。

而且你要說取代，也真的沒那麼快。不然洗碗工早就都被洗碗機取代了。早上街道的打掃人員怎麼沒有被一堆掃地機器人取代。喊這種話的就是騙騙你而已，製造你的資訊落差的恐懼感。

ChatGPT 是 AI 的奇點？

結論：不是

我覺得 ChatGPT 不是奇點，比較像是一個敲門磚。他終於突破了機器要理解人語言的意思。我覺得要可以達到奇點是需要他可以延伸到期啊的地方。怎麼說呢就是他現在還是文字上的回饋，如果今天叫他去幫我訂披薩。他可以直接用 API 或轉換成語音打電話過去應對。這一連串可以都自動地接起來，做到這種地步。我個人認為才是一個奇點。但我相信 ChatGPT 的成功會加速這個的發生

後續發展的預想

很多人說工作會被 AI 提升效率，會讓做事情變得更輕鬆。從一開始接觸 GitHub Copilot 到 ChatGPT。我會說其實真的沒有變得更輕鬆，人們會容易變成神化這個些 AI，尤其當人們沒有基礎知識的時候。

我已經開始可以預想以後會有小孩或老人拿著 AI 產生的內容去質問醫生說「AI 說這個藥可以吃，為什麼你不開給我藥」

人需要轉換成一個「領導者」而不是「依靠者」，而作為一個領導者將會要求更多的更廣泛的知識量。就像是我在使用 GitHub Copliot 的時候，他會產生一些樣板，但如果沒有一定的程式基礎你就看不出來需要再優化的問題。

資訊將會變得更多樣且極為擬真，將更要求人們的辨別能力，而要有更強的辨別能力將需要更多的知識。所以你說會變更輕鬆嗎？我覺得不會。

• mkcert：開發工具，產生一個本地使用的 HTTPS 憑證
• sqlcommenter：用於檢測 ORM 成效的工具
• wallace-cli：用於分析 CSS 的工具
• Recoil：Recoil 是一個用於 React 應用程序的實驗性狀態管理庫。它提供了一些單獨使用 React 難以實現的功能，同時兼容 React 的最新功能。
• mariana trench：針對 Android 和 Java 應用程序的安全性靜態分析工具。
• Browser fingerprinting：用可用的對策分析機器人保護系統🚿。抓取網頁時如何擊敗反殭屍系統👻並繞過瀏覽器指紋腳本🕵️‍♂️？
• Python anti pattern：Python 開發的反指標
• BentoJS：AMP 團隊所開發的
• kpt：一個 Git 原生、模式感知、可擴展的客戶端工具，用於打包、定制、驗證和應用 Kubernetes 資源。

Terminal

• sampler：用於 shell 命令執行、可視化和警報的工具
• kube-prompt：提供自動補齊 kubernetes 指令的工具
• termshark：在 Terminal 使用類似 Wireshark 的工具

Privacy Policy

• 中文隱私權政策樣板

Security

• authov：掃描網站權限覆蓋
• Fucking algorithm
• The Ultimate Guide to the Google Search Parameters
• Disapproved Ads Auditor
• Kondo：用於清除電腦非必要的空間
• npkill：列出所有系統內的 node_module 並可以清除
• pyroscope：About Continuous Profiling Platform! Debug performance issues down to a single line of code
• xstate

Interview

• Coding interview university：成為一個軟體工程師的面試準備
• The Complete FAANG Preparation：用於搜集所有準備 FAANG 工作的面試問題
• 面試背後的面試
• System design primer：了解如何設計大型系統。準備系統設計面試。包括 Anki 抽認卡。

題目敘述

SQL Schema >

Create table If Not Exists SalesPerson (sales_id int, name varchar(255), salary int, commission_rate int, hire_date date) Create table If Not Exists Company (com_id int, name varchar(255), city varchar(255)) Create table If Not Exists Orders (order_id int, order_date date, com_id int, sales_id int, amount int) Truncate table SalesPerson insert into SalesPerson (sales_id, name, salary, commission_rate, hire_date) values ('1', 'John', '100000', '6', '4/1/2006') insert into SalesPerson (sales_id, name, salary, commission_rate, hire_date) values ('2', 'Amy', '12000', '5', '5/1/2010') insert into SalesPerson (sales_id, name, salary, commission_rate, hire_date) values ('3', 'Mark', '65000', '12', '12/25/2008') insert into SalesPerson (sales_id, name, salary, commission_rate, hire_date) values ('4', 'Pam', '25000', '25', '1/1/2005') insert into SalesPerson (sales_id, name, salary, commission_rate, hire_date) values ('5', 'Alex', '5000', '10', '2/3/2007') Truncate table Company insert into Company (com_id, name, city) values ('1', 'RED', 'Boston') insert into Company (com_id, name, city) values ('2', 'ORANGE', 'New York') insert into Company (com_id, name, city) values ('3', 'YELLOW', 'Boston') insert into Company (com_id, name, city) values ('4', 'GREEN', 'Austin') Truncate table Orders insert into Orders (order_id, order_date, com_id, sales_id, amount) values ('1', '1/1/2014', '3', '4', '10000') insert into Orders (order_id, order_date, com_id, sales_id, amount) values ('2', '2/1/2014', '4', '5', '5000') insert into Orders (order_id, order_date, com_id, sales_id, amount) values ('3', '3/1/2014', '1', '1', '50000') insert into Orders (order_id, order_date, com_id, sales_id, amount) values ('4', '4/1/2014', '1', '4', '25000')

Table: SalesPerson

+-----------------+---------+ | Column Name | Type | +-----------------+---------+ | sales_id | int | | name | varchar | | salary | int | | commission_rate | int | | hire_date | date | +-----------------+---------+ sales_id is the primary key column for this table. Each row of this table indicates the name and the ID of a salesperson alongside their salary, commission rate, and hire date.

Table: Company

+-------------+---------+ | Column Name | Type | +-------------+---------+ | com_id | int | | name | varchar | | city | varchar | +-------------+---------+ com_id is the primary key column for this table. Each row of this table indicates the name and the ID of a company and the city in which the company is located.

Table: Orders

+-------------+------+ | Column Name | Type | +-------------+------+ | order_id | int | | order_date | date | | com_id | int | | sales_id | int | | amount | int | +-------------+------+ order_id is the primary key column for this table. com_id is a foreign key to com_id from the Company table. sales_id is a foreign key to sales_id from the SalesPerson table. Each row of this table contains information about one order. This includes the ID of the company, the ID of the salesperson, the date of the order, and the amount paid.

Write an SQL query to report the names of all the salespersons who did not have any orders related to the company with the name "RED".

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input: SalesPerson table: +----------+------+--------+-----------------+------------+ | sales_id | name | salary | commission_rate | hire_date | +----------+------+--------+-----------------+------------+ | 1 | John | 100000 | 6 | 4/1/2006 | | 2 | Amy | 12000 | 5 | 5/1/2010 | | 3 | Mark | 65000 | 12 | 12/25/2008 | | 4 | Pam | 25000 | 25 | 1/1/2005 | | 5 | Alex | 5000 | 10 | 2/3/2007 | +----------+------+--------+-----------------+------------+ Company table: +--------+--------+----------+ | com_id | name | city | +--------+--------+----------+ | 1 | RED | Boston | | 2 | ORANGE | New York | | 3 | YELLOW | Boston | | 4 | GREEN | Austin | +--------+--------+----------+ Orders table: +----------+------------+--------+----------+--------+ | order_id | order_date | com_id | sales_id | amount | +----------+------------+--------+----------+--------+ | 1 | 1/1/2014 | 3 | 4 | 10000 | | 2 | 2/1/2014 | 4 | 5 | 5000 | | 3 | 3/1/2014 | 1 | 1 | 50000 | | 4 | 4/1/2014 | 1 | 4 | 25000 | +----------+------------+--------+----------+--------+ Output: +------+ | name | +------+ | Amy | | Mark | | Alex | +------+ Explanation: According to orders 3 and 4 in the Orders table, it is easy to tell that only salesperson John and Pam have sales to company RED, so we report all the other names in the table salesperson.

題目翻譯

解法解析

這邊使用了 SubQuery 來篩選條件，我們可以先思考子條件

解法範例

MySQL

# Write your MySQL query statement below
SELECT s.name
FROM salesperson s
WHERE s.sales_id NOT IN (
        SELECT o.sales_id
        FROM orders o
            LEFT JOIN company c ON o.com_id = c.com_id
        WHERE c.name = 'RED'
    );

題目敘述

SQL Schema >

Create table If Not Exists Users (user_id int, join_date date, favorite_brand varchar(10)) Create table If Not Exists Orders (order_id int, order_date date, item_id int, buyer_id int, seller_id int) Create table If Not Exists Items (item_id int, item_brand varchar(10)) Truncate table Users insert into Users (user_id, join_date, favorite_brand) values ('1', '2018-01-01', 'Lenovo') insert into Users (user_id, join_date, favorite_brand) values ('2', '2018-02-09', 'Samsung') insert into Users (user_id, join_date, favorite_brand) values ('3', '2018-01-19', 'LG') insert into Users (user_id, join_date, favorite_brand) values ('4', '2018-05-21', 'HP') Truncate table Orders insert into Orders (order_id, order_date, item_id, buyer_id, seller_id) values ('1', '2019-08-01', '4', '1', '2') insert into Orders (order_id, order_date, item_id, buyer_id, seller_id) values ('2', '2018-08-02', '2', '1', '3') insert into Orders (order_id, order_date, item_id, buyer_id, seller_id) values ('3', '2019-08-03', '3', '2', '3') insert into Orders (order_id, order_date, item_id, buyer_id, seller_id) values ('4', '2018-08-04', '1', '4', '2') insert into Orders (order_id, order_date, item_id, buyer_id, seller_id) values ('5', '2018-08-04', '1', '3', '4') insert into Orders (order_id, order_date, item_id, buyer_id, seller_id) values ('6', '2019-08-05', '2', '2', '4') Truncate table Items insert into Items (item_id, item_brand) values ('1', 'Samsung') insert into Items (item_id, item_brand) values ('2', 'Lenovo') insert into Items (item_id, item_brand) values ('3', 'LG') insert into Items (item_id, item_brand) values ('4', 'HP')

Table: Users

+----------------+---------+ | Column Name | Type | +----------------+---------+ | user_id | int | | join_date | date | | favorite_brand | varchar | +----------------+---------+ user_id is the primary key of this table. This table has the info of the users of an online shopping website where users can sell and buy items.

Table: Orders

+---------------+---------+ | Column Name | Type | +---------------+---------+ | order_id | int | | order_date | date | | item_id | int | | buyer_id | int | | seller_id | int | +---------------+---------+ order_id is the primary key of this table. item_id is a foreign key to the Items table. buyer_id and seller_id are foreign keys to the Users table.

Table: Items

+---------------+---------+ | Column Name | Type | +---------------+---------+ | item_id | int | | item_brand | varchar | +---------------+---------+ item_id is the primary key of this table.

Write an SQL query to find for each user, the join date and the number of orders they made as a buyer in 2019.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input: Users table: +---------+------------+----------------+ | user_id | join_date | favorite_brand | +---------+------------+----------------+ | 1 | 2018-01-01 | Lenovo | | 2 | 2018-02-09 | Samsung | | 3 | 2018-01-19 | LG | | 4 | 2018-05-21 | HP | +---------+------------+----------------+ Orders table: +----------+------------+---------+----------+-----------+ | order_id | order_date | item_id | buyer_id | seller_id | +----------+------------+---------+----------+-----------+ | 1 | 2019-08-01 | 4 | 1 | 2 | | 2 | 2018-08-02 | 2 | 1 | 3 | | 3 | 2019-08-03 | 3 | 2 | 3 | | 4 | 2018-08-04 | 1 | 4 | 2 | | 5 | 2018-08-04 | 1 | 3 | 4 | | 6 | 2019-08-05 | 2 | 2 | 4 | +----------+------------+---------+----------+-----------+ Items table: +---------+------------+ | item_id | item_brand | +---------+------------+ | 1 | Samsung | | 2 | Lenovo | | 3 | LG | | 4 | HP | +---------+------------+ Output: +-----------+------------+----------------+ | buyer_id | join_date | orders_in_2019 | +-----------+------------+----------------+ | 1 | 2018-01-01 | 1 | | 2 | 2018-02-09 | 2 | | 3 | 2018-01-19 | 0 | | 4 | 2018-05-21 | 0 | +-----------+------------+----------------+

題目翻譯

這邊有三張表 Users, Orders, Items，找出每個使用者加入的時間和在 2019 年購買了多少訂單，不要求排序。

解法解析

這邊有提到幾點說明為什麼不使用 WHERE 為什麼不使用 ISNULL，因為按照 SQL 執行的順序會是：

1. FROM
2. WHERE
3. GROUP BY
4. HAVING
5. SELECT
6. ORDER BY

如果我們在 WHERE 子句中使用 Year is 2019，它將在執行 GROUP BY 或 SELECT(COUNT)之前，先移除那些沒有在 2019 年下單的用戶，這意味著我們會錯過那些在 2019 年沒有下單但仍需要在最終結果集中包含的用戶，並為他們的 orders_in_2019 設置為 0。相反，我們使用 LEFT JOIN 來將 Users 表格與 Orders 表格連接起來，透過這個方式篩選出只有當 buyer_id 和 user_id 相符且 order_date 的年份為 2019 的行，這樣就能確保所有的用戶都包含在最終結果集中，即使他們在 2019 年沒有下單。

解法範例

MySQL

# Write your MySQL query statement below
SELECT u.user_id AS buyer_id,
    join_date,
    COUNT(order_date) AS orders_in_2019
FROM Users as u
    LEFT JOIN Orders as o ON u.user_id = o.buyer_id
    AND YEAR(order_date) = '2019'
GROUP BY u.user_id

題目敘述

SQL Schema >

Create table If Not Exists ActorDirector (actor_id int, director_id int, timestamp int) Truncate table ActorDirector insert into ActorDirector (actor_id, director_id, timestamp) values ('1', '1', '0') insert into ActorDirector (actor_id, director_id, timestamp) values ('1', '1', '1') insert into ActorDirector (actor_id, director_id, timestamp) values ('1', '1', '2') insert into ActorDirector (actor_id, director_id, timestamp) values ('1', '2', '3') insert into ActorDirector (actor_id, director_id, timestamp) values ('1', '2', '4') insert into ActorDirector (actor_id, director_id, timestamp) values ('2', '1', '5') insert into ActorDirector (actor_id, director_id, timestamp) values ('2', '1', '6')

Table: ActorDirector

+-------------+---------+ | Column Name | Type | +-------------+---------+ | actor_id | int | | director_id | int | | timestamp | int | +-------------+---------+ timestamp is the primary key column for this table.

Write a SQL query for a report that provides the pairs (actor_id, director_id) where the actor has cooperated with the director at least three times.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input: ActorDirector table: +-------------+-------------+-------------+ | actor_id | director_id | timestamp | +-------------+-------------+-------------+ | 1 | 1 | 0 | | 1 | 1 | 1 | | 1 | 1 | 2 | | 1 | 2 | 3 | | 1 | 2 | 4 | | 2 | 1 | 5 | | 2 | 1 | 6 | +-------------+-------------+-------------+ Output: +-------------+-------------+ | actor_id | director_id | +-------------+-------------+ | 1 | 1 | +-------------+-------------+ Explanation: The only pair is (1, 1) where they cooperated exactly 3 times.

題目翻譯

解法解析

解法範例

MySQL

# Write your MySQL query statement below
SELECT actor_id,
    director_id
FROM ActorDirector
GROUP BY actor_id,
    director_id
HAVING count(*) >= 3;

題目敘述

SQL Schema >

Create table If Not Exists Person (id int, email varchar(255)) Truncate table Person insert into Person (id, email) values ('1', 'a@b.com') insert into Person (id, email) values ('2', 'c@d.com') insert into Person (id, email) values ('3', 'a@b.com')

Table: Person

+-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | email | varchar | +-------------+---------+ id is the primary key column for this table. Each row of this table contains an email. The emails will not contain uppercase letters.

Write an SQL query to report all the duplicate emails.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input: Person table: +----+---------+ | id | email | +----+---------+ | 1 | a@b.com | | 2 | c@d.com | | 3 | a@b.com | +----+---------+ Output: +---------+ | Email | +---------+ | a@b.com | +---------+ Explanation: a@b.com is repeated two times.

題目翻譯

解法解析

解法範例

MySQL

題目敘述

SQL Schema:

Create table If Not Exists Activity (player_id int, device_id int, event_date date, games_played int)
Truncate table Activity
insert into Activity (player_id, device_id, event_date, games_played) values ('1', '2', '2016-03-01', '5')
insert into Activity (player_id, device_id, event_date, games_played) values ('1', '2', '2016-05-02', '6')
insert into Activity (player_id, device_id, event_date, games_played) values ('2', '3', '2017-06-25', '1')
insert into Activity (player_id, device_id, event_date, games_played) values ('3', '1', '2016-03-02', '0')
insert into Activity (player_id, device_id, event_date, games_played) values ('3', '4', '2018-07-03', '5')

Table: Activity

+--------------+---------+
| Column Name  | Type    |
+--------------+---------+
| player_id    | int     |
| device_id    | int     |
| event_date   | date    |
| games_played | int     |
+--------------+---------+
(player_id, event_date) is the primary key of this table.
This table shows the activity of players of some games.
Each row is a record of a player who logged in and played a number of games (possibly 0) before logging out on someday using some device.

Write an SQL query to report the first login date for each player.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input:
Activity table:
+-----------+-----------+------------+--------------+
| player_id | device_id | event_date | games_played |
+-----------+-----------+------------+--------------+
| 1         | 2         | 2016-03-01 | 5            |
| 1         | 2         | 2016-05-02 | 6            |
| 2         | 3         | 2017-06-25 | 1            |
| 3         | 1         | 2016-03-02 | 0            |
| 3         | 4         | 2018-07-03 | 5            |
+-----------+-----------+------------+--------------+
Output:
+-----------+-------------+
| player_id | first_login |
+-----------+-------------+
| 1         | 2016-03-01  |
| 2         | 2017-06-25  |
| 3         | 2016-03-02  |
+-----------+-------------+

題目翻譯

解法解析

解法範例

MySQL

# Write your MySQL query statement below
SELECT
    player_id,
    MIN(event_date) AS first_login
FROM
    activity
GROUP BY
    player_id

題目敘述

SQL Schema >

Create table If Not Exists Followers(user_id int, follower_id int)
Truncate table Followers
insert into Followers (user_id, follower_id) values ('0', '1')
insert into Followers (user_id, follower_id) values ('1', '0')
insert into Followers (user_id, follower_id) values ('2', '0')
insert into Followers (user_id, follower_id) values ('2', '1')

Table: Followers

+-------------+------+
| Column Name | Type |
+-------------+------+
| user_id     | int  |
| follower_id | int  |
+-------------+------+
(user_id, follower_id) is the primary key for this table.
This table contains the IDs of a user and a follower in a social media app where the follower follows the user.

Write an SQL query that will, for each user, return the number of followers.

Return the result table ordered by user_id in ascending order.

The query result format is in the following example.

Example 1:

Input:
Followers table:
+---------+-------------+
| user_id | follower_id |
+---------+-------------+
| 0       | 1           |
| 1       | 0           |
| 2       | 0           |
| 2       | 1           |
+---------+-------------+
Output:
+---------+----------------+
| user_id | followers_count|
+---------+----------------+
| 0       | 1              |
| 1       | 1              |
| 2       | 2              |
+---------+----------------+
Explanation:
The followers of 0 are {1}
The followers of 1 are {0}
The followers of 2 are {0,1}

題目翻譯

找出每個 user_id 有多少不重複的 follower_id，並且最後按照 user_id 做升冪排序

解法解析

不重複 => DISTINCT, GROUP BY 升冪排序 => ORDER BY ASC

解法範例

MySQL

# Write your MySQL query statement below
SELECT user_id,
    COUNT(DISTINCT follower_id) AS followers_count
FROM Followers
GROUP BY user_id
ORDER BY user_id ASC

題目敘述

SQL Schema >

Create table If Not Exists DailySales(date_id date, make_name varchar(20), lead_id int, partner_id int)
Truncate table DailySales
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-8', 'toyota', '0', '1')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-8', 'toyota', '1', '0')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-8', 'toyota', '1', '2')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-7', 'toyota', '0', '2')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-7', 'toyota', '0', '1')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-8', 'honda', '1', '2')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-8', 'honda', '2', '1')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-7', 'honda', '0', '1')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-7', 'honda', '1', '2')
insert into DailySales (date_id, make_name, lead_id, partner_id) values ('2020-12-7', 'honda', '2', '1')

Table: DailySales

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| date_id     | date    |
| make_name   | varchar |
| lead_id     | int     |
| partner_id  | int     |
+-------------+---------+
This table does not have a primary key.
This table contains the date and the name of the product sold and the IDs of the lead and partner it was sold to.
The name consists of only lowercase English letters.

Write an SQL query that will, for each date_id and make_name, return the number of distinct lead_id's and distinct partner_id's.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input:
DailySales table:
+-----------+-----------+---------+------------+
| date_id   | make_name | lead_id | partner_id |
+-----------+-----------+---------+------------+
| 2020-12-8 | toyota    | 0       | 1          |
| 2020-12-8 | toyota    | 1       | 0          |
| 2020-12-8 | toyota    | 1       | 2          |
| 2020-12-7 | toyota    | 0       | 2          |
| 2020-12-7 | toyota    | 0       | 1          |
| 2020-12-8 | honda     | 1       | 2          |
| 2020-12-8 | honda     | 2       | 1          |
| 2020-12-7 | honda     | 0       | 1          |
| 2020-12-7 | honda     | 1       | 2          |
| 2020-12-7 | honda     | 2       | 1          |
+-----------+-----------+---------+------------+
Output:
+-----------+-----------+--------------+-----------------+
| date_id   | make_name | unique_leads | unique_partners |
+-----------+-----------+--------------+-----------------+
| 2020-12-8 | toyota    | 2            | 3               |
| 2020-12-7 | toyota    | 1            | 2               |
| 2020-12-8 | honda     | 2            | 2               |
| 2020-12-7 | honda     | 3            | 2               |
+-----------+-----------+--------------+-----------------+
Explanation:
For 2020-12-8, toyota gets leads = [0, 1] and partners = [0, 1, 2] while honda gets leads = [1, 2] and partners = [1, 2].
For 2020-12-7, toyota gets leads = [0] and partners = [1, 2] while honda gets leads = [0, 1, 2] and partners = [1, 2].

題目翻譯

要從資料表 DailySales 中取出每個 date_id 和 make_name 的組合中，不重複的 lead_id 和 partner_id 總數。

解法解析

光看到不重複的第一直覺就是要使用到 DISTINCT，然後再來是有組合的，就會需要搭配使用 GROUP BY 了。最後因為要算個數所以再搭配使用 COUNT 來做計算

解法範例

MySQL

# Write your MySQL query statement below
SELECT date_id,
    make_name,
    COUNT(DISTINCT lead_id) AS unique_leads,
    COUNT(DISTINCT partner_id) AS unique_partners
FROM DailySales
GROUP BY date_id,
    make_name

題目敘述

SQL Schema >

Create table If Not Exists Employees (employee_id int, name varchar(30), salary int)
Truncate table Employees
insert into Employees (employee_id, name, salary) values ('2', 'Meir', '3000')
insert into Employees (employee_id, name, salary) values ('3', 'Michael', '3800')
insert into Employees (employee_id, name, salary) values ('7', 'Addilyn', '7400')
insert into Employees (employee_id, name, salary) values ('8', 'Juan', '6100')
insert into Employees (employee_id, name, salary) values ('9', 'Kannon', '7700')

Table: Employees

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| employee_id | int     |
| name        | varchar |
| salary      | int     |
+-------------+---------+
employee_id is the primary key for this table.
Each row of this table indicates the employee ID, employee name, and salary.

Write an SQL query to calculate the bonus of each employee. The bonus of an employee is 100% of their salary if the ID of the employee is an odd number and the employee's name does not start with the character 'M'. The bonus of an employee is 0 otherwise.

Return the result table ordered by employee_id.

The query result format is in the following example.

Example 1:

Input:
Employees table:
+-------------+---------+--------+
| employee_id | name    | salary |
+-------------+---------+--------+
| 2           | Meir    | 3000   |
| 3           | Michael | 3800   |
| 7           | Addilyn | 7400   |
| 8           | Juan    | 6100   |
| 9           | Kannon  | 7700   |
+-------------+---------+--------+
Output:
+-------------+-------+
| employee_id | bonus |
+-------------+-------+
| 2           | 0     |
| 3           | 0     |
| 7           | 7400  |
| 8           | 0     |
| 9           | 7700  |
+-------------+-------+
Explanation:
The employees with IDs 2 and 8 get 0 bonus because they have an even employee_id.
The employee with ID 3 gets 0 bonus because their name starts with 'M'.
The rest of the employees get a 100% bonus.

題目翻譯

從資料表 Employees 計算出每個員工的獎金，其中如果員工的 ID 是奇數且員工名稱字首不是 M 開頭，則獎金會為 0。最後回傳員工 ID 和獎金。

解法解析

這題需要使用條件式的判斷來選擇最後要回傳的獎金是不是 0，這裡範例使用了 IF 函數和 CASE 來處理。

解法範例

SQL

# Write your MySQL query statement below
SELECT employee_id,
    IF(
        employee_id % 2 = 1
        AND name NOT LIKE 'M%',
        salary,
        0
    ) AS bonus
FROM `Employees`
ORDER BY employee_id;

# Write your MySQL query statement below
SELECT employee_id,
    CASE
        WHERE employee_id %2 <> 0
            AND name NOT LIKE 'M%' THEN salary
            ELSE 0
    END AS bonus
FROM `Employees`
ORDER BY employee_id;

題目敘述

SQL Schema >

Create table If Not Exists Products (product_id int, low_fats ENUM('Y', 'N'), recyclable ENUM('Y','N'))
Truncate table Products
insert into Products (product_id, low_fats, recyclable) values ('0', 'Y', 'N')
insert into Products (product_id, low_fats, recyclable) values ('1', 'Y', 'Y')
insert into Products (product_id, low_fats, recyclable) values ('2', 'N', 'Y')
insert into Products (product_id, low_fats, recyclable) values ('3', 'Y', 'Y')
insert into Products (product_id, low_fats, recyclable) values ('4', 'N', 'N')

Table: Products

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| product_id  | int     |
| low_fats    | enum    |
| recyclable  | enum    |
+-------------+---------+
product_id is the primary key for this table.
low_fats is an ENUM of type ('Y', 'N') where 'Y' means this product is low fat and 'N' means it is not.
recyclable is an ENUM of types ('Y', 'N') where 'Y' means this product is recyclable and 'N' means it is not.

Write an SQL query to find the ids of products that are both low fat and recyclable.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input:
Products table:
+-------------+----------+------------+
| product_id  | low_fats | recyclable |
+-------------+----------+------------+
| 0           | Y        | N          |
| 1           | Y        | Y          |
| 2           | N        | Y          |
| 3           | Y        | Y          |
| 4           | N        | N          |
+-------------+----------+------------+
Output:
+-------------+
| product_id  |
+-------------+
| 1           |
| 3           |
+-------------+
Explanation: Only products 1 and 3 are both low fat and recyclable.

題目翻譯

從資料表 Products 找出所有可以回收且低脂肪的產品 id，並且不需考慮排序。

解法解析

很間單的 WHERE 篩選。

解法範例

SQL

# Write your MySQL query statement below
SELECT product_id
FROM `Products`
WHERE low_fats = "Y"
    AND recyclable = "Y";

題目敘述

SQL Schema >

Create table If Not Exists World (name varchar(255), continent varchar(255), area int, population int, gdp int)
Truncate table World
insert into World (name, continent, area, population, gdp) values ('Afghanistan', 'Asia', '652230', '25500100', '20343000000')
insert into World (name, continent, area, population, gdp) values ('Albania', 'Europe', '28748', '2831741', '12960000000')
insert into World (name, continent, area, population, gdp) values ('Algeria', 'Africa', '2381741', '37100000', '188681000000')
insert into World (name, continent, area, population, gdp) values ('Andorra', 'Europe', '468', '78115', '3712000000')
insert into World (name, continent, area, population, gdp) values ('Angola', 'Africa', '1246700', '20609294', '100990000000')

Table: World

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| name        | varchar |
| continent   | varchar |
| area        | int     |
| population  | int     |
| gdp         | int     |
+-------------+---------+
name is the primary key column for this table.
Each row of this table gives information about the name of a country, the continent to which it belongs, its area, the population, and its GDP value.

A country is big if:

• it has an area of at least three million (i.e., 3000000 km2), or
• it has a population of at least twenty-five million (i.e., 25000000).

Write an SQL query to report the name, population, and area of the big countries.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input:
World table:
+-------------+-----------+---------+------------+--------------+
| name        | continent | area    | population | gdp          |
+-------------+-----------+---------+------------+--------------+
| Afghanistan | Asia      | 652230  | 25500100   | 20343000000  |
| Albania     | Europe    | 28748   | 2831741    | 12960000000  |
| Algeria     | Africa    | 2381741 | 37100000   | 188681000000 |
| Andorra     | Europe    | 468     | 78115      | 3712000000   |
| Angola      | Africa    | 1246700 | 20609294   | 100990000000 |
+-------------+-----------+---------+------------+--------------+
Output:
+-------------+------------+---------+
| name        | population | area    |
+-------------+------------+---------+
| Afghanistan | 25500100   | 652230  |
| Algeria     | 37100000   | 2381741 |
+-------------+------------+---------+

題目翻譯

從資料表 World 找出大城市並回傳其 name, population, area，並且不須排序。而大城市的定義是：

• 區域面積至少 3,000,000
• 人口數至少 25,000,000

解法解析

解法範例

SQL

# Write your MySQL query statement below
SELECT name,
    population,
    area
FROM `World`
WHERE area >= 3000000
    OR population >= 25000000;

第二種寫法沒有特別的必要，只是寫來表示也是有這種寫法，就是用 UNION 來連結兩個 Query。

# Write your MySQL query statement below
SELECT name,
    population,
    area
FROM `World`
WHERE area >= 3000000
UNION
SELECT name,
    population,
    area
FROM `World`
WHERE population >= 25000000;

題目敘述

SQL Schema >

Create table If Not Exists Customer (id int, name varchar(25), referee_id int)
Truncate table Customer
insert into Customer (id, name, referee_id) values ('1', 'Will', 'None')
insert into Customer (id, name, referee_id) values ('2', 'Jane', 'None')
insert into Customer (id, name, referee_id) values ('3', 'Alex', '2')
insert into Customer (id, name, referee_id) values ('4', 'Bill', 'None')
insert into Customer (id, name, referee_id) values ('5', 'Zack', '1')
insert into Customer (id, name, referee_id) values ('6', 'Mark', '2')

Table: Customer

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| id          | int     |
| name        | varchar |
| referee_id  | int     |
+-------------+---------+
id is the primary key column for this table.
Each row of this table indicates the id of a customer, their name, and the id of the customer who referred them.

Write an SQL query to report the names of the customer that are not referred by the customer with id = 2.

Return the result table in any order.

The query result format is in the following example.

Example 1:

Input:
Customer table:
+----+------+------------+
| id | name | referee_id |
+----+------+------------+
| 1  | Will | null       |
| 2  | Jane | null       |
| 3  | Alex | 2          |
| 4  | Bill | null       |
| 5  | Zack | 1          |
| 6  | Mark | 2          |
+----+------+------------+
Output:
+------+
| name |
+------+
| Will |
| Jane |
| Bill |
| Zack |
+------+

題目翻譯

現在有一張資料表 Customer，編寫一個 SQL Query 在不要求排序的情況下找出，沒有連接到 id = 2 的 customer。

解法解析

基本上就是簡單的用 WHERE 關鍵字來篩選即可，需要注意的就是其中 referee_id 是有 NULL 的值，如果只單純用 <> 2 或 != 2 會沒有辦法比對出來。所以需要再加上 IS NULL 的條件。

解法範例

SQL

# Write your MySQL query statement below
SELECT name
FROM `Customer`
WHERE referee_id <> 2
    OR referee_id IS NULL;

要年末的，最近都在忙工作沒有好好的更新 Blog 都要生草了，該來寫點東西了。表示自己還活著呢。

Frontend

覺得開始出現有別於以往御三家的狀態，開始有些人嘗試打破現狀，出現了些滿有意思的 Framework 像是 Qwik。還有因為 Compile 的新工具 Vite 而有其對抗的 Nextjs 的 Turbopack（難怪在 GitHub 一直有人叫他支援 Vite，就是死都不要。原來自己搞了一套）。覺得另外一個滿有看點的就是 Deno 宣佈將會開始往支援 npm 的方向靠攏，會不會有大批的人員從 Nodejs 加入，還不好說但覺得也是個有可能的發展。

個人並不特別看好 TypeScript，經歷過早期的 CoffeeScript 時期，目前覺得 TypeScript 就是新一代的 CoffeeScript，等到 JavaScript 的迭代應該就會將其優點加入。到頭來你還是需要好好的先把 JavaScript 先寫好再說。後續未來發展覺得重點會是慢慢開始往 micro frontend 和 WASM 靠攏，再來就是預期會有更多的 Lite ML 的加入。

Backend

Rust 的蓬勃發展的算是有擠壓到 Go 的範疇，也算是有把 C 家族的人帶進來。但我覺得其學習曲線還是有點高，可能發展上還會有些需要再調整的。Go 的泛型還不是很完善，但總是有在進步。個人滿期許 Kotlin 在跨平台到 Server Side 的可能性，但是目前覺得還沒有很爆炸性的成長和實例。

個人覺得在 Backend 伺服器的語言選擇上，會比較推薦 Node.js、Python 和 Java 作為優先的選擇。可能跟個人經驗有關，在常常需要串接第三方服務，像是 Google、Facebook 等。常常會有的 SDK 這三種語言是最常見的，且社群的發展的套件也是多樣在早期找尋 Solution 會比較方便。

MariaDB 居然上市了？坦白說自己還沒什麼聽到比較有名的使用上跟 MySQL 的差異或優勢。如果真的要選擇更優異的還可能直接去選擇 PostgreSQL。

在於監控上比較有看頭的就是 Grafana 體系了，有別於過去大眾的選擇 ELK 體系，Grafana 也開始自成一個系列依序的提供了 Loki、Tempo、Mimir 等，對於 ELK 體系應該挺有壓力的。

Cloud

Cloud 上目前的三強鼎立（其實應該沒有鼎立），GCP 感覺就還是維持他的砸錢買服務整併的策略，但是在 Cotainer 服務上還是幾乎是首選。AWS 的 EKS 真的就是個半殘品，其他的 Container 服務也是差不多。但是 AWS 的厲害之處就是服務的多樣和各種 Open Source的選擇。個人滿佩服的就是搞定出 macOS 的 EC2，之前要弄 Apple 系列的 CI/CD 就是要買台裝置在公司內，現在真的有機會完全 Cloud 了。再來是過去 GCP 可以說有台灣機房，但是現在 AWS 也有提供台灣 Local Zone 了，其優勢也被略減。

未來 Cloud 服務的發展應該會依舊的往 ML Data 的處理和多雲管理的方向走。

目前感覺：

• AWS 依舊強勁

• Azure 微軟體系首選，穩定發展

• GCP 容器化首選，拼裝車

Mobile

Swift 的發展目前略微擔心，之前有爆出大佬出走，批評內部決策的問題。希望是能好好發展。Kotlin 感覺是個還在耕耘跨平台的方向，但是 Google 目前秘密研製的 FuchsiaOS。未來 Google 會不會正式 GA FuchsiaOS 後屏棄 Android 系統，不再以 Kotlin 為首選還是難說呢。

SRE

Kubernetes 依舊橫掃全場，沒有什麼好說的。依舊的強勁，目前還沒有其他的對手出現。但是手動建制和維運還是相當困難的一件事（畢竟本身服務就很複雜了），還是建議直接使用雲端服務吧。

在 Infrastructure As Code 的領域，HashiCorp 系列也依然強勁，尤其是與 AWS 合作推出的 cdktf 讓其觸角更延伸了。但是還是希望 terraform 本身可以好好學習一下 terragrunt 的優點，當服務一大之後那個要 plan 或 apply state 真的是很久且 dependency 容易出錯。或是拓展出 plugin 的系統，可以有更多的變化。

題目敘述

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.

Example 1:

Input: nums = [1,2,3,1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
Total amount you can rob = 1 + 3 = 4.

Example 2:

Input: nums = [2,7,9,3,1]
Output: 12
Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
Total amount you can rob = 2 + 9 + 1 = 12.

Constraints:

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 400

題目翻譯

假設你是一個專業的搶匪，今天的目標是要搶劫一條街上的房子。每個房子都有防盜系統，其條件是當同一晚相鄰的兩間房子都被闖入時會報警。給定一個陣列 nums，每個索引代表每間房子最多可以搶到多少錢。計算出最多可以搶到多少錢。

解法解析

其解法可以分為三種：Recursion、Iteration 和空間優化後的 Iteration。因為搶了第一間房子的話就不能搶第二間，解答是依據每次的選擇堆疊而成的。所以是典型的 Dynamic programming 問題。

主要的關鍵邏輯就是，每次選擇房子的時候是拿後面兩個來比較。目前在 i = 0 的位置，因為搶了 i = 0 的房子的話，就不能搶 i = 1 的房子。這樣的話至少 i[0] + i[2] >= i[1]才比較有效益，不然的話就是選擇i[1]` 的房子了。每次的選擇都是基於此條件，最後堆疊出最後的答案。

解法範例

Go

Recursion with Memoization

func rob(nums []int) int {
    if len(nums) == 0 {
        return 0
    }
    var memo map[int]int = make(map[int]int, len(nums))
    return robFrom(memo, 0, nums)
}

func robFrom(memo map[int]int, i int, nums []int) int {
    if i >= len(nums) {
        return 0
    }

    if _, ok := memo[i]; ok {
        return memo[i]
    }
    if robFrom(memo, i+1, nums) > robFrom(memo, i+2, nums)+nums[i] {
        memo[i] = robFrom(memo, i+1, nums)
    } else {
        memo[i] = robFrom(memo, i+2, nums) + nums[i]
    }
    return memo[i]
}

Dynamic Programming

func rob(nums []int) int {
    if len(nums) == 0 {
        return 0
    }

    var N int = len(nums)
    var maxRobbedAmount []int = make([]int, N+1)

    maxRobbedAmount[N], maxRobbedAmount[N-1] = 0, nums[N-1]
    for i := N - 2; i >= 0; i-- {
        if maxRobbedAmount[i+1] > maxRobbedAmount[i+2]+nums[i] {
            maxRobbedAmount[i] = maxRobbedAmount[i+1]
        } else {
            maxRobbedAmount[i] = maxRobbedAmount[i+2] + nums[i]
        }
    }
    return maxRobbedAmount[0]
}

Optimized Dynamic Programming

func rob(nums []int) int {
    if len(nums) == 0 {
        return 0
    }
    var N int = len(nums)
    var robNext, robNextPlusOne int = nums[N-1], 0
    for i := N - 2; i >= 0; i-- {
        if robNext > robNextPlusOne+nums[i] {
            robNext, robNextPlusOne = robNext, robNext
        } else {
            robNext, robNextPlusOne = robNextPlusOne+nums[i], robNext
        }
    }
    return robNext
}

JavaScript

Recursion with Memoization

/**
 * @param {number[]} nums
 * @return {number}
 */
const rob = function (nums) {
    const memo = {};

    const robFrom = (i, rob_nums) => {
        if (i >= rob_nums.length) {
            return 0;
        }
        if (i in memo) {
            return memo[i];
        }
        const ans = Math.max(rob_nums[i] + robFrom(i + 2, rob_nums), robFrom(i + 1, rob_nums));
        memo[i] = ans;
        return ans;
    };

    return robFrom(0, nums);
};

Dynamic Programming

/**
 * @param {number[]} nums
 * @return {number}
 */
const rob = function (nums) {
    if (!nums) {
        return 0;
    }

    const N = nums.length;
    const maxRobbedAmount = new Array(N + 1).fill(0);
    maxRobbedAmount[N] = 0;
    maxRobbedAmount[N - 1] = nums[N - 1];

    for (let i = N - 2; i >= 0; i--) {
        maxRobbedAmount[i] = Math.max(nums[i] + maxRobbedAmount[i + 2], maxRobbedAmount[i + 1]);
    }
    return maxRobbedAmount[0];
};

Optimized Dynamic Programming

/**
 * @param {number[]} nums
 * @return {number}
 */
const rob = function (nums) {
    if (!nums) {
        return 0;
    }

    const N = nums.length;
    let robNextPlusOne = 0,
        robNext = nums[N - 1];

    for (let i = N - 2; i >= 0; i--) {
        const current = Math.max(robNext, robNextPlusOne + nums[i]);
        robNextPlusOne = robNext;
        robNext = current;
    }
    return robNext;
};

Kotlin

Recursion with Memoization

class Solution {
    protected lateinit var memo: MutableMap<Int, Int>

    fun rob(nums: IntArray): Int {
        memo = mutableMapOf()
        return robFrom(0, nums)
    }

    fun robFrom(i: Int, nums: IntArray): Int {
        if (i >= nums.size) return 0
        if (memo[i] != null) return memo[i]!!
        val res = Math.max(robFrom(i + 1, nums), nums[i] + robFrom(i + 2, nums))
        memo[i] = res
        return res
    }
}

Dynamic Programming

class Solution {
    fun rob(nums: IntArray): Int {
        if (nums.size == 0) {
            return 0
        }

        val N: Int = nums.size
        var maxRobbedAmount: IntArray = IntArray(N + 1)
        maxRobbedAmount[N] = 0
        maxRobbedAmount[N - 1] = nums[N - 1]
        for (i in N - 2 downTo 0) {
            maxRobbedAmount[i] = Math.max(maxRobbedAmount[i + 1], maxRobbedAmount[i + 2] + nums[i])
        }
        return maxRobbedAmount[0]
    }
}

Optimized Dynamic Programming

class Solution {
    fun rob(nums: IntArray): Int {
        if (nums.size == 0) {
            return 0
        }

        val N: Int = nums.size
        var robNext: Int = nums[N - 1]
        var robNextPlusOne: Int = 0
        for (i in N - 2 downTo 0) {
            val current: Int = Math.max(robNext, robNextPlusOne + nums[i])
            robNextPlusOne = robNext
            robNext = current
        }
        return robNext
    }
}

PHP

Recursion with Memoization

class Solution
{
    private $memo = [];

    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function rob($nums)
    {
        return $this->robFrom(0, $nums);
    }

    function robFrom($i, $nums)
    {
        if ($i >= count($nums)) {
            return 0;
        }
        if (isset($this->memo[$i])) {
            return $this->memo[$i];
        }
        $ans = max($this->robFrom($i + 1, $nums), $this->robFrom($i + 2, $nums) + $nums[$i]);
        $this->memo[$i] = $ans;
        return $ans;
    }
}

Dynamic Programming

class Solution
{
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function rob($nums)
    {
        if (empty($nums)) {
            return 0;
        }
        $N = count($nums);
        $maxRobbedAmount = array_fill(0, $N + 1, 0);
        $maxRobbedAmount[$N] = 0;
        $maxRobbedAmount[$N - 1] = $nums[$N - 1];
        for ($i = $N - 2; $i >= 0; $i--) {
            $maxRobbedAmount[$i] = max($maxRobbedAmount[$i + 1], $maxRobbedAmount[$i + 2] + $nums[$i]);
        }
        return $maxRobbedAmount[0];
    }
}

Optimized Dynamic Programming

class Solution
{
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function rob($nums)
    {
        if (empty($nums)) {
            return 0;
        }
        $N = count($nums);
        $robNext = $nums[$N - 1];
        $robNextPlusOne = 0;
        for ($i = $N - 2; $i >= 0; $i--) {
            $current = max($robNext, $robNextPlusOne + $nums[$i]);
            $robNextPlusOne = $robNext;
            $robNext = $current;
        }
        return $robNext;
    }
}

Python

Recursion with Memoization

class Solution:
    def __init__(self) -> None:
        self.memo: dict[int, int] = {}

    def rob(self, nums: list[int]) -> int:
        self.memo = {}
        return self.robFrom(0, nums)

    def robFrom(self, i: int, nums: list[int]) -> int:
        # No more houses left to examine.
        if i >= len(nums):
            return 0

        # Return cached value.
        if i in self.memo:
            return self.memo[i]

        # Recursive relation evaluation to get the optimal answer.
        ans: int = max(self.robFrom(i + 1, nums), self.robFrom(i + 2, nums) + nums[i])

        # Cache for future use.
        self.memo[i] = ans
        return ans

Dynamic Programming

class Solution:
    def rob(self, nums: list[int]) -> int:
        # Special handling for empty case.
        if not nums:
            return 0

        N: int = len(nums)
        maxRobbedAmount: list[int | None] = [None for _ in range(N + 1)]

        # Base case initialization.
        maxRobbedAmount[N], maxRobbedAmount[N - 1] = 0, nums[N - 1]

        # DP table calculations.
        for i in range(N - 2, -1, -1):

            # Same as recursive solution.
            maxRobbedAmount[i] = max(
                maxRobbedAmount[i + 1], maxRobbedAmount[i + 2] + nums[i]
            )

        return maxRobbedAmount[0]

Optimized Dynamic Programming

class Solution:
    def rob(self, nums: list[int]) -> int:

        # Special handling for empty case.
        if not nums:
            return 0

        N: int = len(nums)

        rob_next_plus_one: int = 0
        rob_next: int = nums[N - 1]

        # DP table calculations.
        for i in range(N - 2, -1, -1):

            # Same as recursive solution.
            current: int = max(rob_next, rob_next_plus_one + nums[i])

            # Update the variables
            rob_next_plus_one = rob_next
            rob_next = current

        return rob_next

Rust

Swift

Recursion with Memoization

class Solution {

    var memo: [Int: Int] = [Int: Int]()

    func rob(_ nums: [Int]) -> Int {
        return robFrom(0, nums: nums)
    }

    func robFrom(_ i: Int, nums: [Int]) -> Int {
        if i >= nums.count {
            return 0
        }
        if let memoized: Int = memo[i] {
            return memoized
        }
        let result: Int = max(robFrom(i + 1, nums: nums), nums[i] + robFrom(i + 2, nums: nums))
        memo[i] = result
        return result
    }
}

Dynamic Programming

class Solution {
    func rob(_ nums: [Int]) -> Int {
        if nums.count == 0 {
            return 0
        }

        let N: Int = nums.count
        var maxRobbedAmount: [Int] = Array(repeating: 0, count: N + 1)
        maxRobbedAmount[N] = 0
        maxRobbedAmount[N - 1] = nums[N - 1]

        for i: Int in (0..<N - 1).reversed() {
            maxRobbedAmount[i] = max(maxRobbedAmount[i + 1], nums[i] + maxRobbedAmount[i + 2])
        }

        return maxRobbedAmount[0]
    }
}

Optimized Dynamic Programming

class Solution {
    func rob(_ nums: [Int]) -> Int {
        if nums.count == 0 {
            return 0
        }

        let N: Int = nums.count
        var robNextPlusOne: Int = 0
        var robNext: Int = nums[N - 1]

        for i: Int in (0..<N - 1).reversed() {
            let current: Int = max(robNext, nums[i] + robNextPlusOne)
            robNextPlusOne = robNext
            robNext = current
        }
        return robNext
    }
}

This article is for recording how I set up the AWS EKS for the team.

Here are my requirements.

• I could use SSM and SSH keys to access EKS workers from a bastion instance.
• All EKS add-ons could install and work.
• ALB could create and accept requests from the internet.
• Worker will only host at the private subnet.

Here is my network architecture.

• Build a two-tier network on VPC.
• Build a bastion instance on the public subnet.

1. Set up authorize

Before setting up an EKS, we must prepare the IAM role and security groups for services.

IAM

• EKS Master
• EKS Worker
• Vertical Pod Autoscaler
• Application Load Balancer

According to AWS doc

Due to VPA and ALB will use IRSA, therefore we need to wait for EKS creation to finish, then create OIDC. So the IAM role for VPA and ALB will be created later.

Role for EKS Master

Trust policy：

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "eks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

And attach the policies：

• AmazonEKSClusterPolicy.

Role for EKS Worker

Trust policy：

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "ec2.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

And attach the policies：

• AmazonEBSCSIDriverPolicy, for add-on EBS
• AmazonEC2ContainerRegistryReadOnly, for ECR
• AmazonEKS_CNI_Policy, for add-on VPC CNI, if you use IPv6 then you need to create the policy yourself.
• AmazonEKSWorkerNodePolicy, for EKS worker
• AmazonSSMManagedInstanceCore, for session manager

Security Group

• EKS Master
• EKS Worker

EKS will create default security groups for the master and node. But I want use the default one, therefore I create other to manage.

Here are the rules.

Security group for EKS Master

Security group for EKS Worker

2. Build up Kubernetes

At this step, I will use terraform to create the EKS, including OIDC with EKS. You could check the demo at this repository.

Note: Adot will install fail, we will add the required settings in the next steps. My demo includes creating OIDC.

After creation, we could run this command to get credential to kubeconfig.

aws eks update-kubeconfig --region <REGION> --name <CLUSTER_NAME>

3. Add Add-On and services

After EKS is created, we will need to add some services to make our services better.

Metrics Server

This is a very important component in EKS. Horizontal Pod Autoscaler and Vertical Pod Autoscaler depend on this. So we need to install it first.

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
kubectl get deployment metrics-server -n kube-system

Reference

• Installing the Kubernetes Metrics Server

AWS Distro for OpenTelemetry

1. Create a Service account & Namespace for Adot

    kubectl apply -f https://amazon-eks.s3.amazonaws.com/docs/addons-otel-permissions.yaml
    kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.9.1/cert-manager.yaml
   

2. Create IRSA for Adot

    eksctl create iamserviceaccount \
        --name adot-collector \
        --namespace <NAMESPACE> \
        --cluster <CLUSTER_NAME> \
        --attach-policy-arn arn:aws:iam::aws:policy/AmazonPrometheusRemoteWriteAccess \
        --attach-policy-arn arn:aws:iam::aws:policy/AWSXrayWriteOnlyAccess \
        --attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
        --approve \
        --override-existing-serviceaccounts
   

3. Install collector

   • CloudWatch
     • Download YAML：curl -o collector-config-cloudwatch.yaml https://raw.githubusercontent.com/aws-observability/aws-otel-community/master/sample-configs/operator/collector-config-cloudwatch.yaml
     • Replace values
       • serviceAccount: Check this value should be the same as the previous name field adot-collector
       • value: <YOUR_EKS_CLUSTER_NAME>
       • region: <YOUR_AWS_REGION>
       • name: Check this value should be the same as the previous name field adot-collector
     • Apply YAML：kubectl apply -f collector-config-cloudwatch.yaml
   • X-Ray
     • Download YAML：curl -o collector-config-xray.yaml https://raw.githubusercontent.com/aws-observability/aws-otel-community/master/sample-configs/operator/collector-config-xray.yaml
     • Replace values
       • serviceAccount: Check this value should be the same as the previous name field adot-collector
       • value: <YOUR_EKS_CLUSTER_NAME>
       • region: <YOUR_AWS_REGION>
     • Apply YAML：kubectl apply -f collector-config-xray.yaml
   • Prometheus on Daemonset
     • Download YAML：curl -o collector-config-advanced.yaml https://raw.githubusercontent.com/aws-observability/aws-otel-community/master/sample-configs/operator/collector-config-advanced.yaml
     • Replace values
       • serviceAccount: Check this value should be the same as the previous name field adot-collector
       • value: <YOUR_EKS_CLUSTER_NAME>
       • region: <YOUR_AWS_REGION>
       • name: Check this value should be the same as the previous name field adot-collector
     • Apply YAML：kubectl apply -f collector-config-advanced.yaml

Reference

• Amazon EKS add-on support for ADOT Operator
• AWS Distro for OpenTelemetry

Vertical Pod Autoscaler

Requirements

• Install metrics server
• kubectl could communicate with your Amazon EKS cluster.
• OpenSSL 1.1.1 or later installed on your device which is support -addext option.

Installation

1. Download repository：git clone https://github.com/kubernetes/autoscaler.git
2. Go inside：cd autoscaler/vertical-pod-autoscaler/
3. Deploy VPA：./hack/vpa-up.sh：If your OpenSSL is not supported -addext option, you will fail at this step.

If you install another OpenSSL version with another naming. You could change the OpenSSL command naming at autoscaler/vertical-pod-autoscaler/pkg/admission-controller/gencerts.sh. For example, I install openssl11 on Amazon Linux. Then I change the openssl to openssl11 at gencerts.sh.

If you have already deployed another version of the Vertical Pod Autoscaler, remove it with the following command.

./hack/vpa-down.sh

Reference

• Vertical Pod Autoscaler

Application Load Balancer

Before we install the ALB controller, we need to install External-DNS first. External-DNS could help us update the Route53 record while we could ingress with ALB. But if your ALB is not planning to open to the internet, you could skip this step.

This ALB required OIDC.

Install external-dns

1. Create IAM Policy

    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Action": ["route53:ChangeResourceRecordSets"],
                "Resource": ["arn:aws:route53:::hostedzone/*"]
            },
            {
                "Effect": "Allow",
                "Action": ["route53:ListHostedZones", "route53:ListResourceRecordSets"],
                "Resource": ["*"]
            }
        ]
    }
   

2. Create IRSA. Replace $POLICY_ARN value with IAM policy's arn at step 1.

    eksctl create iamserviceaccount \
        --cluster $EKS_CLUSTER_NAME \
        --name "external-dns" \
        --namespace ${EXTERNALDNS_NS:-"default"} \
        --attach-policy-arn $POLICY_ARN \
        --approve
   

3. Save external-dns YAML file.

   Save to YAML

    # comment out sa if it was previously created
    apiVersion: v1
    kind: ServiceAccount
    metadata:
        name: external-dns
        labels:
            app.kubernetes.io/name: external-dns
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata:
        name: external-dns
        labels:
            app.kubernetes.io/name: external-dns
    rules:
        - apiGroups: ['']
          resources: ['services', 'endpoints', 'pods', 'nodes']
          verbs: ['get', 'watch', 'list']
        - apiGroups: ['extensions', 'networking.k8s.io']
          resources: ['ingresses']
          verbs: ['get', 'watch', 'list']
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata:
        name: external-dns-viewer
        labels:
            app.kubernetes.io/name: external-dns
    roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: ClusterRole
        name: external-dns
    subjects:
        - kind: ServiceAccount
          name: external-dns
          namespace: default # change to desired namespace: externaldns, kube-addons
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
        name: external-dns
        labels:
            app.kubernetes.io/name: external-dns
    spec:
        strategy:
            type: Recreate
        selector:
            matchLabels:
                app.kubernetes.io/name: external-dns
        template:
            metadata:
                labels:
                    app.kubernetes.io/name: external-dns
            spec:
                serviceAccountName: external-dns
                containers:
                    - name: external-dns
                      image: k8s.gcr.io/external-dns/external-dns:v0.11.0
                      args:
                          - --source=service
                          - --source=ingress
                          - --domain-filter=example.com # will make ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones
                          - --provider=aws
                          - --policy=upsert-only # would prevent ExternalDNS from deleting any records, omit to enable full synchronization
                          - --aws-zone-type=public # only look at public hosted zones (valid values are public, private or no value for both)
                          - --registry=txt
                          - --txt-owner-id=external-dns
                      env:
                          - name: AWS_DEFAULT_REGION
                            value: us-east-1 # change to region where EKS is installed
                # # Uncommend below if using static credentials
                #        - name: AWS_SHARED_CREDENTIALS_FILE
                #          value: /.aws/credentials
                #      volumeMounts:
                #        - name: aws-credentials
                #          mountPath: /.aws
                #          readOnly: true
                #  volumes:
                #    - name: aws-credentials
                #      secret:
                #        secretName: external-dns
   

4. Replace to values at step 3 YAML file.

   • Comment Service account section. We have already created the service account in step 2.
   • Change the --domain-filter to your domain
   • Change env AWS_DEFAULT_REGION to your region.

5. Deploy external-dns.

    kubectl create --filename externaldns-with-rbac.yaml --namespace ${EXTERNALDNS_NS:-"default"}
   

Install AWS Load Balancer Controller

Requirements

• Create IAM OIDC for EKS
• Install EKS Add-ons：VPC CNI, kube-proxy, and CoreDNS
• Install Helm

Installation

1. Create IAM Policy AWSLoadBalancerControllerIAMPolicy

    aws iam create-policy \
        --policy-name AWSLoadBalancerControllerIAMPolicy \
        --policy-document https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.4.3/docs/install/iam_policy.json
   

2. Create IRSA, and replace values.

   • <IAM_POLICY> with IAM policy arn at step 1
   • <EKS_CLUSTER> EKS cluster name

   • <ROLE_NAME> IAM role name

     eksctl create iamserviceaccount \
       --cluster=<EKS_CLUSTER> \
       --namespace=kube-system \
       --name=aws-load-balancer-controller \
       --role-name <ROLE_NAME> \
       --attach-policy-arn=<IAM_POLICY> \
       --approve \
       --override-existing-serviceaccounts
     

3. Install the AWS Load Balancer Controller using Helm V3

    helm repo add eks https://aws.github.io/eks-charts
    helm repo update
    helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
        -n kube-system \
        --set clusterName=<EKS_CLUSTER> \
        --set serviceAccount.create=false \
        --set serviceAccount.name=aws-load-balancer-controller
   

Reference

• Setting up ExternalDNS for Services on AWS
• Installing the AWS Load Balancer Controller add-on
• AWS Load Balancer Controller
• Application load balancing on Amazon EKS

此篇將介紹單一 VPC 情況下，AWS 的解決方案有哪些，也提供了哪些服務和整個網路流量的流程。

從上圖可以先列出有的服務

• VPC
• Subnet
• Network ACL
• Security Group
• Internet Gateway
  • Elastic IP
  • egress-only Internet Gateway
• NAT Gateway / NAT Instance

VPC

一個 VPC 是邏輯層上的網路隔離，可以想像其中有獨立的網域 IP 和網路環境。VPC 在一個 Region，跨 AZ 的網路環境(無法 Cross Region)。一個 Region 中可以有多個 VPC。

在建立 VPC 的時候，需要指定 IPv4 的 CIDR 範圍(必須的)，此外也能設定 IPv6 的範圍。

• IPv4 (CIDR 接受 16 ~ 28)
  • CIDR 手動設定
  • IPAM 管理
• IPv6
  • IPAM 管理
  • Amazon 提供（固定長度為 /56）
  • 自有的 IPv6 CIDR

需要注意建立時的 CIDR 範圍不能與現有的其他 VPC 重疊，可以參考限制。預設 一個 Region 最多有 5 個 VPC，可以申請擴充最多到 100 個。

最後可以設定 Tenancy，這是表示說當選擇為 Dedicated 時，代表在這 VPC 中使用的 EC2 都會是 dedicated tenancy instances，不管其 tenancy 設定為何。

IPAM 是一個 IP 管理服務，後續會再詳細介紹。這邊先知道如果選擇由 IPAM 管理的話，則 VPC 的 CIDR 大小會由 IPAM 的規則來規範。

IPv6 如果選擇使用 Amazon 提供的話，會像 Amazon 的 IPv6 位址池申請，會固定其長度在 /56，無法做修改。

IPv4 最多可以跟 5 個 CIDR 範圍關聯也可以取消關聯，但是只能全部取消，不能選擇 CIDR 中的一部分取消。

如果要刪除 VPC 的話，需要先中止或刪除 VPC 內的 ENI。

DNS resolution 是由 Route53 resolver 處理，如果沒有開啟此設定就會需要自己建立 DNS Server。

DNS hostnames 則是每個有 Public IP 的 Instance 都會有一個對應的 Public hostname

如果 Route53 有設定 Private host zone 就必須開啟以上兩個 DNS 設定。

預設 VPC

一開始使用 VPC 時，AWS 會在每個 Region 建立預設的 VPC。預設會附帶以下服務。

• VPC

  • 預設 CIDR 172.31.0.0/16

• Public subnet

  • 預設每個 AZ 有 CIDR /20 長度
• Internet gateway
• Network ACL
• Route table：將 0.0.0.0/0 指向 Internet gateway
• DNS options set

Subnet

VPC 下可以再區分不同的 Subnet，在實際場景上我們通常可能會區分三層式網路架構：Access layer、Application layer、Core layer。但是如果再簡化一點，我們可以就是分兩層：Public layer 和 Private layer。後續的服務也會先依照兩層的方式做說明。

在 VPC 有說到是單一 Region 的，Subnet 則是單一 AZ 的，而且 CIDR 的範圍是要在 VPC CIDR 的範圍內，所以在建立時需要指定 AZ 和 CIDR。根據 VPC 的設定 subnet 也可以決定是只要有 IPv4 還是 IPv6 還是兩者皆有。

要注意 Amazon 會預留 5 個 IP 位置，無法使用每個 Subnet CIDR 中的前四個 IP 地址和最後一個 IP 地址，並且無法將這些 IP 地址指派給資源，如 EC2 執行個體。IPv4 和 IPv6 都會。

而大多數的網路服務都會是依靠在 Subnet 之下，通常如果有連接 Internet gateway 的 subnet 為視為是 Public subnet，反之就是 Private subnet。Private subnet 無法連向外網也無法被外網連接，只能透過 Public subnet 做連線。

Route Table

Route Table 包含一組規則(稱為 route)，用來決定 Subnet 或 Gateway 的網路流量被導向到哪裡。每個 VPC 中會有一個預設的 Main route table 會控制所有並未與任何其他 Route Table 建立關聯之 Subnet 的流量。Route Table 一但跟 Subnet 做關聯就無法被刪除。實作上建議保留預設 Route Table，建立其他 Route Table 做規則上的疊加。Route Table 跟 Subnet 之間的關係是多對一，一個 Subnet 只能關聯一個 Route Table，但一個 Route Table 可以給多個 Subnet 使用。

預設下 VPC 中 Subnet 之間的流量會依靠 Local route 達到互通，而 Local route 是預設且無法修改的，只要是沒有跟其他 Route Table 做關聯的流量就會自動被其管理。IPv4 和 IPv6 的 route 是需要分別設定的。當不同的 Subnet 之間要溝通的時候，實際上會先透過 local route 做中繼站。

• Destination：您希望 IP 地址範圍（目標 CIDR）的流量要被導向
• Target：流量要被導向的目標

Gateway Route Table

如果 Route Table 有關聯到 Internet Gateway 或是 Virtual Private Gateway 的話，可以被稱為 Gateway Route Table，用來控制進入到 VPC 的流量。

其他再額外延伸的還有跟 Transit Gateways 關聯的 Transit gateway route table 和跟 AWS Outposts 關聯的 Local gateway route table。

Network ACL

Network ACL 可以看作是 Subnet 層級的防火牆服務，用來允許或拒絕 Subnet inbound 和 outbound 的流量。系統一樣會有預設的 Network ACL，設定為允許所有流量流進和流出其相關聯的 subnet。

Network ACL 跟 Subnet 的關聯跟 Route Table 一樣，多對一的關係。沒有關聯的就會使用預設的 Network ACL。

Network ACL 是屬於 Stateless 服務，所以 inbound 和 outbound 要分別設定，可以看作是處理黑名單的管理，Rule 值越小權限越高，相同值時則以 DENY 為優先。

要注意規則上的設定，不然可能會造成一些 AWS 服務不能正常運作。例如可能把 ELB status check 不能正常運作。

Security Group

Instance 層級的防火牆設定，屬於 stateful 服務因為其狀態會保存，當 Inbound 中允許的規則會自動開放對應的 outbound。即使移除 allow outbound traffic 的規則依舊還是可以連通。是唯一可以用來管控 Subnet 之間的流量方式。只能設定 allow rules，管控白名單，所以跟 Network ACL 不同沒有 Deny。其底層是使用了 Elastic Network Interface 類似虛擬網卡的方式做處理。預設阻擋所有 inbound，但允許所有 outbound。要注意 Name 在 VPC 中要是唯一的。

前面的服務都在介紹的是流量在 VPC 內的控制，接下來的部分則是往外連線出去的服務

Internet gateway

Internet Gateway 是一個水平擴展具有備援且高可用的 VPC 元件，可以讓 Subnet 中的服務連線到外部網路，或是讓外部網路做連線，也因此跟 Internet Gateway 做關聯的 Subnet 會被稱作 Public Subnet。主要的兩個功能：可以在 VPC Route Table 中作為外網流量的目標，以及針對已獲 Public IPv4 Instance 執行 NAT。

Elastic IP

如果要對外存取的話，該 Instance 需要具有 Public IP 或是有跟 Elastic IP 做關聯。而 Elastic IP 是一個靜態的 Public IP，可以跟任意的 Instance 或 Network Interface 做關聯。有點像是你就固定好一個 IP 位址，然後可以決定要指派到哪個 Instances。不管換到哪個 Instance，其對外的 IP 都是固定的。

Egress-only Internet Gateway

算是一個分支的服務，主要是提供 Private Subnet 中 IPv6 對外網存取的管道(但不包含讓外網存取)。IPv4 的話則是會使用 NAT。

NAT gateway / NAT instance

如果今天在 Private Subnet 中的服務需要存取外網或是其他 VPC 的服務，就需要使用 NAT。可以選擇使用 AWS 管理的 NAT Gateway 或是在 EC2 上建立自己的 NAT instance。

NAT Gateway

• 是獨立 AZ 的，可以多個 AZ 共用一個，或是每個 AZ 有各自的 NAT Gateway
• 支援以下通訊協定：TCP、UDP 和 ICMP
• 支援 5 Gbps 的頻寬，並可自動擴展至 100 Gbps。
• 每秒可以處理 100 萬個封包，並自動擴展至每秒 1000 萬個封包。若超過會丟棄封包
• 可支援最多 55,000 個連至每個唯一目標的同時連線

NAT Device

需要建立自己的 NAT AMI，因為 AWS 自 2020/12/31 已正式停止支援，會建議直接使用 NAT Gateway 更快。需要建立在 Public Subnet 中，需要關閉 Source & Destination Check，才能 Proxy 其他 Instance 的封包，需要額外設定 Security Group，Private Subnet 也需要設定 Route 導向 NAT Instance。其乘載量取決於 Instance 的規格，還需要另外自我處理 HA 的問題。

Reference

-使用 Amazon VPC 建置模組化且可擴展的虛擬網路架構

• 邏輯隔離的 Virtual Private Cloud
• 「什麼是 Amazon VPC？」
• 具有單一公有子網路的 VPC

題目敘述

You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.

You can either start from the step with index 0, or the step with index 1.

Return the minimum cost to reach the top of the floor.

Example 1:

Input: cost = [10,15,20]
Output: 15
Explanation: You will start at index 1.

- Pay 15 and climb two steps to reach the top.
The total cost is 15.

Example 2:

Input: cost = [1,100,1,1,1,100,1,1,100,1]
Output: 6
Explanation: You will start at index 0.

- Pay 1 and climb two steps to reach index 2.
- Pay 1 and climb two steps to reach index 4.
- Pay 1 and climb two steps to reach index 6.
- Pay 1 and climb one step to reach index 7.
- Pay 1 and climb two steps to reach index 9.
- Pay 1 and climb one step to reach the top.
The total cost is 6.

Constraints:

• 2 <= cost.length <= 1000
• 0 <= cost[i] <= 999

Hint 1:

Build an array dp where dp[i] is the minimum cost to climb to the top starting from the ith staircase.

Hint 2:

Assuming we have n staircase labeled from 0 to n - 1 and assuming the top is n, then dp[n] = 0, marking that if you are at the top, the cost is 0.

Hint 3:

Now, looping from n - 1 to 0, the dp[i] = cost[i] + min(dp[i + 1], dp[i + 2]). The answer will be the minimum of dp[0] and dp[1]

題目翻譯

會有一個整數陣列 cost 每個位置代表了爬到這一階樓梯要花費的費用，每次移動可以選擇要一階還是兩階。要找出到達最高層時，所需最少的的成本是多少。

解法解析

因為每一次操作的花費成本都是基於之前的操作結果為基礎來計算的，所以是一個典型的 Dynamic programming 的題目。所以當然的就基本上可以有種解法：Tabulation 和 Memoization。

Dynamic Programming 最主要的解法就是找出小問題，因為最後的答案都是基於前面的答案為基礎累積的，所以其實就是每次解出小問題的答案。所以回到最原本的問題，當然就是你要踏出一階還是兩階哪個成本最低。成為函示就是：

minimumCost[i] = min(minimumCost[i - 1] + cost[i - 1], minimumCost[i - 2] + cost[i - 2])

而以下的解法差別就只是在於怎麼處理每次的小問題，依照 Dynamic programming 的解法，基本上就是分為 Tabulation 和 Memoization 兩種方式。

Bottom-Up Dynamic Programming (Tabulation)

這個解法主要就是使用了遍歷的方式來處理

Top-Down Dynamic Programming (Recursion + Memoization)

這一種解決小問題的解法就是遞迴了

Bottom-Up, Constant Space

這個方式跟第一種解法類似，只是不再使用陣列儲存之前處理的結果，而是直接用一個變數紀錄最新的結果。

解法範例

Go

Bottom-Up Dynamic Programming (Tabulation)

func minCostClimbingStairs(cost []int) int {
    var minimumCost []int = make([]int, len(cost)+1)
    for i := 0; i < len(cost); i++ {
        minimumCost[i] = 0
    }
    for i := 2; i <= len(cost); i++ {
        var takeOneStep int = minimumCost[i-1] + cost[i-1]
        var takeTwoStep int = minimumCost[i-2] + cost[i-2]
        if takeOneStep < takeTwoStep {
            minimumCost[i] = takeOneStep
        } else {
            minimumCost[i] = takeTwoStep
        }
    }
    return minimumCost[len(cost)]
}

Top-Down Dynamic Programming (Recursion + Memoization)

func minCostClimbingStairs(cost []int) int {
    var memo map[int]int = make(map[int]int)
    return minimumCost(cost, memo, len(cost))
}

func minimumCost(cost []int, memo map[int]int, i int) int {
    if i <= 1 {
        return 0
    }

    if val, ok := memo[i]; ok {
        return val
    }

    var downOne int = minimumCost(cost, memo, i-1) + cost[i-1]
    var downTwo int = minimumCost(cost, memo, i-2) + cost[i-2]
    if downOne > downTwo {
        memo[i] = downTwo
    } else {
        memo[i] = downOne
    }
    return memo[i]
}

Bottom-Up, Constant Space

func minCostClimbingStairs(cost []int) int {
    var downOne int = 0
    var downTwo int = 0
    for i := 2; i <= len(cost); i++ {
        var temp int = downOne
        if downOne+cost[i-1] < downTwo+cost[i-2] {
            downOne += cost[i-1]
        } else {
            downOne = downTwo + cost[i-2]
        }
        downTwo = temp
    }
    return downOne
}

JavaScript

Bottom-Up Dynamic Programming (Tabulation)

/**
 * @param {number[]} cost
 * @return {number}
 */
var minCostClimbingStairs = function (cost) {
    const minimumCost = new Array(cost.length + 1).fill(0);
    for (let i = 2; i <= cost.length; i++) {
        minimumCost[i] = Math.min(minimumCost[i - 1] + cost[i - 1], minimumCost[i - 2] + cost[i - 2]);
    }
    return minimumCost[cost.length];
};

Top-Down Dynamic Programming (Recursion + Memoization)

/**
 * @param {number[]} cost
 * @return {number}
 */
var minCostClimbingStairs = function (cost) {
    const memo = {};

    const minimumCost = (i) => {
        if (i <= 1) return 0;
        if (i in memo) return memo[i];
        return (memo[i] = Math.min(minimumCost(i - 1) + cost[i - 1], minimumCost(i - 2) + cost[i - 2]));
    };
    return minimumCost(cost.length);
};

Bottom-Up, Constant Space

/**
 * @param {number[]} cost
 * @return {number}
 */
var minCostClimbingStairs = function (cost) {
    let downOne = 0,
        downTwo = 0;
    for (let i = 2; i <= cost.length; i++) {
        const down = Math.min(downOne + cost[i - 1], downTwo + cost[i - 2]);
        downTwo = downOne;
        downOne = down;
    }
    return downOne;
};

Kotlin

Bottom-Up Dynamic Programming (Tabulation)

class Solution {
    fun minCostClimbingStairs(cost: IntArray): Int {
        var minimumCost: IntArray = IntArray(cost.size + 1, { 0 })

        for (i in 2..cost.size) {
            minimumCost[i] =
                    Math.min(minimumCost[i - 1] + cost[i - 1], minimumCost[i - 2] + cost[i - 2])
        }
        return minimumCost[cost.size]
    }
}

Top-Down Dynamic Programming (Recursion + Memoization)

class Solution {
    fun minCostClimbingStairs(cost: IntArray): Int {
        val memo = mutableMapOf<Int, Int>()

        fun minimumCost(i: Int): Int {
            if (i <= 1) return 0
            if (i in memo) return memo[i]!!
            memo[i] = Math.min(minimumCost(i - 1) + cost[i - 1], minimumCost(i - 2) + cost[i - 2])
            return memo[i]!!
        }

        return minimumCost(i = cost.size)
    }
}

Bottom-Up, Constant Space

class Solution {
    fun minCostClimbingStairs(cost: IntArray): Int {
        var downOne: Int = 0
        var downTwo: Int = 0
        for (i in 2..cost.size) {
            val temp: Int = downOne
            downOne = Math.min(downOne + cost[i - 1], downTwo + cost[i - 2])
            downTwo = temp
        }
        return downOne
    }
}

PHP

Bottom-Up Dynamic Programming (Tabulation)

class Solution
{

    /**
     * @param Integer[] $cost
     * @return Integer
     */
    function minCostClimbingStairs($cost)
    {
        $minimumCost = array_fill(0, count($cost) + 1, 0);
        for ($i = 2; $i <= count($cost); $i++) {
            $minimumCost[$i] = min($minimumCost[$i - 1] + $cost[$i - 1], $minimumCost[$i - 2] + $cost[$i - 2]);
        }
        return $minimumCost[count($cost)];
    }
}

Top-Down Dynamic Programming (Recursion + Memoization)

class Solution
{

    /**
     * @param Integer[] $cost
     * @return Integer
     */
    function minCostClimbingStairs($cost)
    {
        $memo = [];
        return $this->minimumCost($cost, count($cost), $memo);
    }

    function minimumCost($cost, $i, $memo)
    {
        if ($i <= 1) {
            return 0;
        }
        if (isset($memo[$i])) {
            return $memo[$i];
        }
        $memo[$i] = min($this->minimumCost($cost, $i - 1, $memo) + $cost[$i - 1], $this->minimumCost($cost, $i - 2, $memo) + $cost[$i - 2]);
        return $memo[$i];
    }
}

Bottom-Up, Constant Space

class Solution
{

    /**
     * @param Integer[] $cost
     * @return Integer
     */
    function minCostClimbingStairs($cost)
    {
        $downOne = 0;
        $downTwo = 0;
        for ($i = 2; $i <= count($cost); $i++) {
            $temp = $downOne;
            $downOne = min($downOne + $cost[$i - 1], $downTwo + $cost[$i - 2]);
            $downTwo = $temp;
        }
        return $downOne;
    }
}

Python

Bottom-Up Dynamic Programming (Tabulation)

class Solution:
    def minCostClimbingStairs(self, cost: list[int]) -> int:
        # The array's length should be 1 longer than the length of cost
        # This is because we can treat the "top floor" as a step to reach
        minimum_cost: list[int] = [0] * (len(cost) + 1)

        # Start iteration from step 2, since the minimum cost of reaching
        # step 0 and step 1 is 0
        for i in range(2, len(cost) + 1):
            take_one_step: int = minimum_cost[i - 1] + cost[i - 1]
            take_two_steps: int = minimum_cost[i - 2] + cost[i - 2]
            minimum_cost[i] = min(take_one_step, take_two_steps)

        # The final element in minimum_cost refers to the top floor
        return minimum_cost[-1]

Top-Down Dynamic Programming (Recursion + Memoization)

class Solution:
    def minCostClimbingStairs(self, cost: list[int]) -> int:
        def minimum_cost(i: int):
            # Base case, we are allowed to start at either step 0 or step 1
            if i <= 1:
                return 0

            # Check if we have already calculated minimum_cost(i)
            if i in memo:
                return memo[i]

            # If not, cache the result in our hash map and return it
            down_one: int = cost[i - 1] + minimum_cost(i - 1)
            down_two: int = cost[i - 2] + minimum_cost(i - 2)
            memo[i] = min(down_one, down_two)
            return memo[i]

        memo: dict[int, int] = {}
        return minimum_cost(len(cost))

Bottom-Up, Constant Space

class Solution:
    def minCostClimbingStairs(self, cost: list[int]) -> int:
        down_one = down_two = 0
        for i in range(2, len(cost) + 1):
            temp: int = down_one
            down_one = min(down_one + cost[i - 1], down_two + cost[i - 2])
            down_two = temp

        return down_one

Rust

Swift

Bottom-Up Dynamic Programming (Tabulation)

class Solution {
    func minCostClimbingStairs(_ cost: [Int]) -> Int {
        var minimumCost: [Int] = Array(repeating: 0, count: cost.count + 1)
        for i in 2...cost.count {
            let takeOneStep: Int = minimumCost[i - 1] + cost[i - 1]
            let takeTwoSteps: Int = minimumCost[i - 2] + cost[i - 2]
            minimumCost[i] = min(takeOneStep, takeTwoSteps)
        }

        return minimumCost[cost.count]
    }
}

Top-Down Dynamic Programming (Recursion + Memoization)

class Solution {
    func minCostClimbingStairs(_ cost: [Int]) -> Int {
        func minimumCost(_ i: Int) -> Int {
            guard i > 1 else {
                return 0
            }

            if let val = memo[i] {
                return val
            }

            let downOne: Int = minimumCost(i - 1) + cost[i - 1]
            let downTwo: Int = minimumCost(i - 2) + cost[i - 2]
            memo[i] = min(downOne, downTwo)
            return memo[i]!
        }

        var memo = [Int: Int]()
        return minimumCost(cost.count)
    }
}

Bottom-Up, Constant Space

class Solution {
    func minCostClimbingStairs(_ cost: [Int]) -> Int {
        var downOne: Int = 0
        var downTwo: Int = 0
        for i in 2...cost.count {
            let temp: Int = downOne
            downOne = min(downOne + cost[i - 1], downTwo + cost[i - 2])
            downTwo = temp
        }
        return downOne
    }
}