├── COPYRIGHT.md
├── README.md
├── docs
    ├── 01-prerequisites.md
    ├── 02-generating-tls-certificate.md
    ├── 03-generating-kubenetes-configuration-file.md
    ├── 04-generating-data-encryption-key.md
    ├── 05-tip-n-trick.md
    ├── 06-transfer-file.md
    ├── 07-install_etcd_cluster.md
    ├── 08-install_kubernetes_control_plane.md
    ├── 09-loadbalancer.md
    ├── 10-install-worker-node.md
    ├── 11-kubernetes-object-authorization.md
    ├── 12-kubectl-remote-access.md
    ├── 13-pod-network.md
    ├── 14-dns-for-services-and-pods.md
    ├── 15-test.md
    └── 16-install-metallb.md
└── images
    ├── README.md
    ├── kube-component.png
    └── ss1.png


/COPYRIGHT.md:
--------------------------------------------------------------------------------
1 | # Copyright
2 | 
3 | <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | > เอกสารฉบับนี้ อ้างอิงจาก Kubernetes The Hard Way ที่ถูกพัฒนาโดย [Kelsey Hightower](https://github.com/kelseyhightower/kubernetes-the-hard-way) และอีกฉบับที่ถูกพัฒนาโดย [Mumshad Mannambeth](https://github.com/mmumshad/kubernetes-the-hard-way)
 2 | # Kubernetes The Hard Way - CentOS
 3 | ใน Repository นี้เป็นเอกสารและข้อมูลติดตั้ง Kubernetes แบบ Kubernetes The Hard Way ตามแนวทางของ Kelsey Hightower จากข้่อมูลในวันที่ 20 กันยายน 2563 แนวของ Kelsey Hightower จะอัางถึงระบบที่ถูกสร้างอยู่ใน Google Cloud Platform ทั้งหมด โดยใช้ Kubernetes v1.18.6 และติดตั้งบนระบบปฏิบัติการ Ubuntu  ผู้เขียนได้พัฒนาและปรับปรุงให้ทันสมัยมากขึ้น และปรับให้ใช้อยู่บนพื้นฐานของระบบปฏิบัติการ CentOS 8 โดยมีเจตนาจะเผยแพร่ให้กับบุคคลทั่วไปที่สนใจศึกษาการติดตั้ง Kubernetes 
 4 | # Copyright
 5 | 
 6 | <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.
 7 | # รายละเอียดของ Kubernetes Cluster
 8 | - Kubernetes 1.19.2
 9 | - Docker 19.3.13
10 | - cni v0.8.7
11 | - etcd v3.4.13
12 | - NGINX v1.14.1 (Loadbalancer)
13 | - ชุด IP ภายใน Cluster 10.96.0.0/24
14 | - Cluster DNS 10.96.0.10
15 | # สารบัญ Kubernetes The Hard Way - CentOS
16 | [01. รายละเอียดในการติดตั้ง](docs/01-prerequisites.md)
17 | 
18 | [02. แนวคิดในการสร้าง TLS Certificate ใน Kubernetes และ สร้าง Certificate Authority กับ TLS Certificate](docs/02-generating-tls-certificate.md)
19 | 
20 | [03. สร้าง Kubernetes Configuration Files สำหรับ Authentication](docs/03-generating-kubenetes-configuration-file.md)
21 | 
22 | [04. สร้าง Data Encryption Config และ Key](docs/04-generating-data-encryption-key.md)
23 | 
24 | [05. เคล็ดไม่ลับ เล็ก ๆ น้อย ๆ](docs/05-tip-n-trick.md)
25 | 
26 | [06. โอนถ่ายไฟล์ที่สร้างไปยัง Virtual Machine](docs/06-transfer-file.md)
27 | 
28 | [07. ติดตั้ง etcd](docs/07-install_etcd_cluster.md)
29 | 
30 | [08. ติดตั้ง Kubernetes Control Plane](docs/08-install_kubernetes_control_plane.md)
31 | 
32 | [09. ติดตั้ง Loadbalancer สำหรับ master node](docs/09-loadbalancer.md)
33 | 
34 | [10, ติดตั้ง Kubernetes Worker Nodes](docs/10-install-worker-node.md)
35 | 
36 | [11. Kubernetes Object Authorization](docs/11-kubernetes-object-authorization.md)
37 | 
38 | [12. สร้าง kubeconfig สำหรับ remote access](docs/12-kubectl-remote-access.md)
39 | 
40 | [13. ติดตั้ง Network สำหรับ Pod](docs/13-pod-network.md)
41 | 
42 | [14. ติดตั้ง DNS สำหรับ Services และ Pods](docs/14-dns-for-services-and-pods.md)
43 | 
44 | [15. ทดสอบการทำงาน](docs/15-test.md)
45 | 
46 | # ขอบคุณ
47 | - ขอบคุณโอกาสที่ได้เรียนรู้จาก MFEC Public Company Limited
48 | - ขอบคุณ @Sirinat Oam Paphatsirinatthi และ @Saritrat Jirakulphondchai จาก @KubeOps Skills ที่พาเดินก้าวแรกให้เรียนรู้
49 | - ขอบคุณ @Sukkarin ที่เป็นเพื่อนคุย เพื่อนคิด ช่วยหาคำตอบตอนที่คิดไม่ออก
50 | - ขอบคุณทุกคนที่เป็นกำลังใจ และฟังเสียงบ่นใน Facebook
51 | 
52 | # สุดท้าย
53 | เอกสารชุดนี้เขียนจากการลองผิด ลองถูก ตามเอกสารที่อ้างอิงของผู้เขียนเอง และเห็นว่าเอกสารชุดนี้ยังไม่มีชุดที่เป็นภาษาไทยจึงได้พัฒนาเอกสารชุดนี้ขึ้นมา ผู้เขียนยินดีรับฟังทุกความคิดเห็นในเชิงสร้างสรรค์ เพื่อช่วยกันพัฒนาเอกสารฉบับนี้ให้เป็นประโยชน์กับผู้ที่ต้องการศึกษา
54 | 
55 | ด้วยจิตคารวะ
56 | 


--------------------------------------------------------------------------------
/docs/01-prerequisites.md:
--------------------------------------------------------------------------------
  1 | # รายละเอียดในการติดตั้ง
  2 | ในขั้นตอนนี้เป็นขั้นตอนการเตรียม Virtual Machine สำหรับติดตั้ง Kubernetes และ Admin Workstation สำหรับเป็นเครื่องมือในการเตรียมข้อมูล และใช้ติดตั้ง Kubernetes ให้พร้อมในการติดตั้ง Kubernetes แบบ The Hard Way 
  3 | ## Admin Workstation
  4 | ในกรณีของผู้เขียนใช้ macOS version 10.15.6 เป็นเครื่องหลักในการติดตั้ง ดังนั้นรายละเอียดในส่วนนี้ ก็จะอ้างอิงกับ macOS แต่เครื่องมือที่จำเป็นก็สามารถติดตั้งในระบบปฏิบัติการ Linux ได้ เครื่องมือจะถูกติดตั้งผ่าน [Homebrew](https://brew.sh/) ที่เป็นเครื่องมือ Package Manager ที่ช่วยอำนวยความสะดวกในการติดตั้ง software เพิ่มเติมใน macOS
  5 | ### ติดตั้ง cfssl และ kubectl 
  6 | ```
  7 | brew install cfssl kubectl
  8 | ```
  9 | > ตรวจสอบการติดตั้ง
 10 | ```
 11 | $ cfssl version
 12 | Version: dev
 13 | Runtime: go1.14
 14 | $ cfssljson --version 
 15 | Version: dev
 16 | Runtime: go1.14
 17 | $ kubectl version --client 
 18 | Client Version: version.Info{Major:"1", Minor:"19", GitVersion:"v1.19.2", GitCommit:"f5743093fd1c663cb0cbc89748f730662345d44d", GitTreeState:"clean", BuildDate:"2020-09-16T21:51:49Z", GoVersion:"go1.15.2", Compiler:"gc", Platform:"darwin/amd64"}
 19 | ```
 20 | นอกจาก software ที่ต้องติดตั้งเพิ่มเติม ก็ยังใช้ software ที่ถูกติดตั้งมาพร้อมกับ macOS อยู่แล้วได้แก่ terminal, ssh client, ssh-keygen
 21 | ### สร้าง Key Pair สำหรับ Authentication เครื่อง Virtual Machine
 22 | ```
 23 | $ ssh-keygen -t ed25519
 24 | Generating public/private ed25519 key pair.
 25 | Enter file in which to save the key (/Users/drs/.ssh/id_ed25519): 
 26 | Enter passphrase (empty for no passphrase):
 27 | Enter same passphrase again:
 28 | Your identification has been saved in id_ed25519.
 29 | Your public key has been saved in id_ed25519.pub.
 30 | The key fingerprint is:
 31 | SHA256:4Ox72ZR/DwqpVCu0LtmN+KQ0BWGgyYI7G6x9QejOYHs drs@Tyche6c.local
 32 | The key's randomart image is:
 33 | +--[ED25519 256]--+
 34 | |    ..o          |
 35 | |.. + . .         |
 36 | |o = . o          |
 37 | |.+ . o o         |
 38 | |=o. . o S ..     |
 39 | |oO.  o o ooo     |
 40 | |o.+E. ++=*+.  .  |
 41 | |  .. .+B=oo..... |
 42 | |      o++   .. ..|
 43 | +----[SHA256]-----+
 44 | ```
 45 | ## Virtual Machine
 46 | ใน lab ของผู้เขียนใช้ [oVirt](https://www.ovirt.org/) เป็นเครื่องมือในการจัดการ ซึ่งแต่ละคนอาจจะใช้เครื่องมือที่ต่างกัน เช่น VirtualBox, VMWare Workstation, VMWare vSphere, VMWare vCenter, OpenStack, Azure Stack หรือจะเป็น Instance ที่ Public Cloud ก็ได้ ในการติดตั้งครั้งนี้ต้องการ Virtual Machine ทั้งหมด 6 เครื่องดังนี้
 47 | |Item|Hostname|IP|Function|
 48 | |----|--------|--|--------|
 49 | |1|api.example.com|192.168.254.60|Loadbalancer|
 50 | |2|master0.example.com|192.168.254.61|Master|
 51 | |3|master1.example.com|192.168.254.62|Master|
 52 | |4|master2.example.com|192.168.254.63|Master|
 53 | |5|node0.example.com|192.168.254.64|Worker|
 54 | |6|node1.example.com|192.168.254.65|Worker|
 55 | > - ทุกเครื่องมี 2 vCPU, Memory 2 GB, HDD 10 GB
 56 | > - ทุกเครื่องมีระบบปฏิบัติการ CentOS 8.2
 57 | > - ติดตั้ง Docker ที่ Worker Node ทั้งสองเครื่อง
 58 | > - ทุกเครื่องสามารถใช้ SSH Key-Based Authentication ได้
 59 | ### ตัวอย่างการโอนถ่าย Public Key ไปยังเครื่อง Virtual Machine เพื่อให้สามารถทำ SSH Key-Based Authentication ได้
 60 | ```
 61 | $ ssh-copy-id root@192.168.254.60
 62 | /usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/Users/drs/.ssh/id_ed25519.pub"
 63 | /usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
 64 | /usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
 65 | root@192.168.254.60's password:
 66 | 
 67 | Number of key(s) added:        1
 68 | 
 69 | Now try logging into the machine, with:   "ssh 'root@192.168.254.60'"
 70 | and check to make sure that only the key(s) you wanted were added.
 71 | ```
 72 | ### ตรวจสอบ Docker ที่ติดตั้งใน Worker Node
 73 | ```
 74 | # docker version
 75 | Client: Docker Engine - Community
 76 |  Version:           19.03.13
 77 |  API version:       1.40
 78 |  Go version:        go1.13.15
 79 |  Git commit:        4484c46d9d
 80 |  Built:             Wed Sep 16 17:03:45 2020
 81 |  OS/Arch:           linux/amd64
 82 |  Experimental:      false
 83 | 
 84 | Server: Docker Engine - Community
 85 |  Engine:
 86 |   Version:          19.03.13
 87 |   API version:      1.40 (minimum version 1.12)
 88 |   Go version:       go1.13.15
 89 |   Git commit:       4484c46d9d
 90 |   Built:            Wed Sep 16 17:02:21 2020
 91 |   OS/Arch:          linux/amd64
 92 |   Experimental:     false
 93 |  containerd:
 94 |   Version:          1.2.13
 95 |   GitCommit:        7ad184331fa3e55e52b890ea95e65ba581ae3429
 96 |  runc:
 97 |   Version:          1.0.0-rc10
 98 |   GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
 99 |  docker-init:
100 |   Version:          0.18.0
101 |   GitCommit:        fec3683
102 | ```
103 | **Next>** [แนวคิดในการสร้าง TLS Certicate ใน Kubernetes และ สร้าง Certificate Authority กับ TLS Certificate](02-generating-tls-certificate.md)
104 | 


--------------------------------------------------------------------------------
/docs/02-generating-tls-certificate.md:
--------------------------------------------------------------------------------
  1 | # แนวคิดในการสร้าง TLS Certificate ใน Kubernetes และ สร้าง Certificate Authority กับ TLS Certificate 
  2 | ในการสื่อสารกับ Kubernetes ทั้งภายในและภายนอก Cluster เรื่องความปลอดภัยในการสื่อสารเป็นเรื่องที่ได้รับการออกแบบให้มีความปลอดภัย และ [TLS (Transport Layer Security)](https://en.wikipedia.org/wiki/Transport_Layer_Security) ก็เป็นวิธีการที่ถูกเลือกใช้ในการจัดการเรื่องนี้ ส่วนเรื่องของการ Authentication ของ client ในการขอเชื่อมต่อก็จะใช้วิธีการที่เรียกว่า [Mutual Authentication แบบ Certificated based](https://en.wikipedia.org/wiki/Mutual_authentication) ดังนั้นจึงจำเป็นต้องสร้าง key pair จำนวนมากในการติดตั้ง Kubernetes
  3 | ## ต้องสร้าง Key Pair ที่ไหนบ้าง 
  4 | ในการใช้งาน TLS ส่วนของการ Authenitation ใน TLS ใช้ [Public-Key Cryptography](https://en.wikipedia.org/wiki/Public-key_cryptography) ในส่วนนี้จึงสร้าง key pair โดยหลักคิดก็คือว่า component ตัวไหนทำหน้าที่เป็น Server ในการให้บริการก็ต้องสร้าง key pair ให้ และ component ไหนทำหน้าที่เป็น client ในการขอใช้บริการก็ต้องสร้าง key pair ให้
  5 | ![Kubernetes and TLS Information](https://github.com/rdamrong/Kubernetes-The-Hard-Way-CentOS/blob/master/images/kube-component.png)
  6 | - วงกลมสีฟ้าที่มีอักษร S แสดงในองค์ประกอบนั้นทำหน้าที่เป็น Server ที่ทำหน้าที่ให้บริการ service ในหน้าที่ของตัวเอง
  7 | - วงกลมสีฟ้าที่มีอักษร C แสดงในองค์ประกอบนั้นทำหน้าที่เป็น Client ต้องขอใช้บริการใน service ที่ต้องการ
  8 | > ในเอกสาร version แรกจะเป็นไปตามแนวทางที่ผู้เขียนอ้างอิงถึงจะมีจุดสังเกตุอยู่ 2 จุด
  9 | > - client key pair จาก kube-apiserver ไปยัง etcd จะใช้ key pair ของ etcd ในการเชื่อมต่อ
 10 | > - client key pair จาก kube-apiserver ไปยัง kubelet จะใช้ key pair ของ kube-apiserver ในการเชื่อมต่อ
 11 | > - client key pair จาก kubelet ไปยัง kube-apiserver จะใช้ key pair ของ kubelet ในการเชื่อมต่อ
 12 | 
 13 | ## สร้าง CA (Certificate Authority) [Admin Workstation]
 14 | ประเด็นหนึ่งในการทำ Mutual Authentication แบบ Certificated based คือ Ceriticate ในฝั่ง Client จะต้องมี Digital Signature ที่ถูก sign จาก CA เดียวกับฝั่ง Server ดังนั้นการสร้าง CA key pair จึงเป็นขั้นตอนแรก และเครื่องมือที่จะช่วยในการสร้าง key pair ก็คือ `cfssl`
 15 | ```
 16 | {
 17 | 
 18 | cat > ca-config.json <<EOF
 19 | {
 20 |   "signing": {
 21 |     "default": {
 22 |       "expiry": "8760h"
 23 |     },
 24 |     "profiles": {
 25 |       "kubernetes": {
 26 |         "usages": ["signing", "key encipherment", "server auth", "client auth"],
 27 |         "expiry": "8760h"
 28 |       }
 29 |     }
 30 |   }
 31 | }
 32 | EOF
 33 | 
 34 | cat > ca-csr.json <<EOF
 35 | {
 36 |   "CN": "Kubernetes",
 37 |   "key": {
 38 |     "algo": "rsa",
 39 |     "size": 2048
 40 |   },
 41 |   "names": [
 42 |     {
 43 |       "C": "TH",
 44 |       "O": "Kubernetes",
 45 |       "OU": "CA",
 46 |       "ST": "Bangkok"
 47 |     }
 48 |   ]
 49 | }
 50 | EOF
 51 | 
 52 | cfssl gencert -initca ca-csr.json | cfssljson -bare ca
 53 | 
 54 | cp ca-key.pem ca.key
 55 | cp ca.pem ca.crt
 56 | 
 57 | }
 58 | 
 59 | ```
 60 | > เนื่องจากผู้เขียน มีความเห็นส่วนตัวเรื่องการตั้งชื่อไฟล์ของ Key และ Certificate ว่าการตั้งไฟล์ที่ลงท้ายด้วย .key และ .crt ทำให้ผู้เขียนจัดการไฟล์ได้สะดวกกว่า
 61 | ## สร้าง Client และ Server Key Pair
 62 | ในส่วนนี้จะเป็นการ Key Pair สำหรับส่วนประกอบต่าง ๆ ที่จำเป็นในการติดตั้ง Kubernetes
 63 | ### สร้าง Admin Client Key Pair
 64 | ```
 65 | {
 66 | cat > admin-csr.json <<EOF
 67 | {
 68 |   "CN": "admin",
 69 |   "key": {
 70 |     "algo": "rsa",
 71 |     "size": 2048
 72 |   },
 73 |   "names": [
 74 |     {
 75 |       "C": "TH",
 76 |       "O": "system:masters",
 77 |       "OU": "Kubernetes The Hard Way CentOS",
 78 |       "ST": "Bangkok"
 79 |     }
 80 |   ]
 81 | }
 82 | EOF
 83 | 
 84 | cfssl gencert \
 85 |   -ca=ca.pem \
 86 |   -ca-key=ca-key.pem \
 87 |   -config=ca-config.json \
 88 |   -profile=kubernetes \
 89 |   admin-csr.json | cfssljson -bare admin
 90 | 
 91 | mv admin-key.pem admin.key
 92 | mv admin.pem admin.crt
 93 | 
 94 | }
 95 | ```
 96 | ### สร้าง Kubelet Client Key Pair
 97 | ใน Kubernetes มีการกำหนดเรื่อง [Node Authorization](https://kubernetes.io/docs/reference/access-authn-authz/node/) เพื่อให้จัดการเรื่องกำหนดสิทธิ์ในการเรียก API ในไปยัง Kubelet เรียกว่า Node Authorizer มีการกำหนด Group ที่ต้องเป็น system:nodes และ Username จะเป็น system:node:<nodeName> ซึ่งจะกำหนดที่ CommonName และ Organization ใน Certificate Attributes
 98 | ```
 99 | {
100 | declare -A NODE_IP
101 | NODE_IP[node0]="192.168.254.64"
102 | NODE_IP[node1]="192.168.254.65"
103 | 
104 | 
105 | for instance in node0 node1; do
106 | cat > ${instance}-csr.json <<EOF
107 | {
108 |   "CN": "system:node:${instance}",
109 |   "key": {
110 |     "algo": "rsa",
111 |     "size": 2048
112 |   },
113 |   "names": [
114 |     {
115 |       "C": "TH",
116 |       "O": "system:nodes",
117 |       "OU": "Kubernetes The Hard Way CentOS",
118 |       "ST": "Bangkok"
119 |     }
120 |   ]
121 | }
122 | EOF
123 | 
124 | 
125 | INTERNAL_IP=${NODE_IP[${instance}]}
126 | echo "\n\nGenerating Key and Cert for "${INTERNAL_IP}" :: "${instance}
127 | 
128 | cfssl gencert \
129 |   -ca=ca.pem \
130 |   -ca-key=ca-key.pem \
131 |   -config=ca-config.json \
132 |   -hostname=${instance},${INTERNAL_IP} \
133 |   -profile=kubernetes \
134 |   ${instance}-csr.json | cfssljson -bare ${instance}
135 | 
136 | mv ${instance}-key.pem ${instance}.key
137 | mv ${instance}.pem ${instance}.crt
138 | done
139 | }
140 | ```
141 | > ในส่วนของการสร้าง Kubelet Client Certificate ทดสอบบน zsh ใน macOS แล้วใช้งานได้ แต่ยังไม่ได้สอบใน bash 
142 | ### สร้าง Controller Manager Client Certificate
143 | ```
144 | {
145 | 
146 | cat > kube-controller-manager-csr.json <<EOF
147 | {
148 |   "CN": "system:kube-controller-manager",
149 |   "key": {
150 |     "algo": "rsa",
151 |     "size": 2048
152 |   },
153 |   "names": [
154 |     {
155 |       "C": "TH",
156 |       "O": "system:kube-controller-manager",
157 |       "OU": "Kubernetes The Hard Way CentOS",
158 |       "ST": "Bangkok"
159 |     }
160 |   ]
161 | }
162 | EOF
163 | 
164 | cfssl gencert \
165 |   -ca=ca.pem \
166 |   -ca-key=ca-key.pem \
167 |   -config=ca-config.json \
168 |   -profile=kubernetes \
169 |   kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager
170 | 
171 | mv kube-controller-manager-key.pem kube-controller-manager.key
172 | mv kube-controller-manager.pem kube-controller-manager.crt
173 | }
174 | 
175 | ```
176 | ### สร้าง Kube Proxy Client Key Pair
177 | ```
178 | {
179 | 
180 | cat > kube-proxy-csr.json <<EOF
181 | {
182 |   "CN": "system:kube-proxy",
183 |   "key": {
184 |     "algo": "rsa",
185 |     "size": 2048
186 |   },
187 |   "names": [
188 |     {
189 |       "C": "TH",
190 |       "O": "system:node-proxier",
191 |       "OU": "Kubernetes The Hard Way CentOS",
192 |       "ST": "Bangkok"
193 |     }
194 |   ]
195 | }
196 | EOF
197 | 
198 | cfssl gencert \
199 |   -ca=ca.pem \
200 |   -ca-key=ca-key.pem \
201 |   -config=ca-config.json \
202 |   -profile=kubernetes \
203 |   kube-proxy-csr.json | cfssljson -bare kube-proxy
204 | 
205 | mv kube-proxy-key.pem kube-proxy.key
206 | mv kube-proxy.pem kube-proxy.crt
207 | }
208 | 
209 | 
210 | ```
211 | ### สร้าง Scheduler Client Key Pair
212 | ```
213 | 
214 | {
215 | 
216 | cat > kube-scheduler-csr.json <<EOF
217 | {
218 |   "CN": "system:kube-scheduler",
219 |   "key": {
220 |     "algo": "rsa",
221 |     "size": 2048
222 |   },
223 |   "names": [
224 |     {
225 |       "C": "TH",
226 |       "O": "system:kube-scheduler",
227 |       "OU": "Kubernetes The Hard Way CentOS",
228 |       "ST": "Bangkok"
229 |     }
230 |   ]
231 | }
232 | EOF
233 | 
234 | cfssl gencert \
235 |   -ca=ca.pem \
236 |   -ca-key=ca-key.pem \
237 |   -config=ca-config.json \
238 |   -profile=kubernetes \
239 |   kube-scheduler-csr.json | cfssljson -bare kube-scheduler
240 | 
241 | mv kube-scheduler-key.pem kube-scheduler.key
242 | mv kube-scheduler.pem kube-scheduler.crt
243 | }
244 | ```
245 | ### สร้าง Kubernetes API Server Key Pair
246 | ```
247 | {
248 | KUBERNETES_HOSTNAMES=master0,master1,master2,kubernetes,kubernetes.default,kubernetes.default.svc,kubernetes.default.svc.cluster,kubernetes.svc.cluster.local
249 | cat > kubernetes-csr.json <<EOF
250 | {
251 |   "CN": "kubernetes",
252 |   "key": {
253 |     "algo": "rsa",
254 |     "size": 2048
255 |   },
256 |   "names": [
257 |     {
258 |       "C": "TH",
259 |       "O": "Kubernetes",
260 |       "OU": "Kubernetes The Hard Way CentOS",
261 |       "ST": "Bangkok"
262 |     }
263 |   ]
264 | }
265 | EOF
266 | 
267 | cfssl gencert \
268 |   -ca=ca.pem \
269 |   -ca-key=ca-key.pem \
270 |   -config=ca-config.json \
271 |   -hostname=10.96.0.1,10.32.0.1,192.168.254.60,192.168.254.61,192.168.254.62,192.168.254.63,127.0.0.1,${KUBERNETES_HOSTNAMES} \
272 |   -profile=kubernetes \
273 |   kubernetes-csr.json | cfssljson -bare kubernetes
274 | 
275 | mv kubernetes-key.pem kube-apiserver.key
276 | mv kubernetes.pem kube-apiserver.crt
277 | }
278 | ```
279 | ### สร้าง Service Account Key Pair
280 | ```
281 | {
282 | 
283 | cat > service-account-csr.json <<EOF
284 | {
285 |   "CN": "service-accounts",
286 |   "key": {
287 |     "algo": "rsa",
288 |     "size": 2048
289 |   },
290 |   "names": [
291 |     {
292 |       "C": "TH",
293 |       "O": "Kubernetes",
294 |       "OU": "Kubernetes The Hard Way CentOS",
295 |       "ST": "Bangkok"
296 |     }
297 |   ]
298 | }
299 | EOF
300 | 
301 | cfssl gencert \
302 |   -ca=ca.pem \
303 |   -ca-key=ca-key.pem \
304 |   -config=ca-config.json \
305 |   -profile=kubernetes \
306 |   service-account-csr.json | cfssljson -bare service-account
307 | 
308 | mv service-account-key.pem service-account.key
309 | mv service-account.pem service-account.crt
310 | }
311 | ```
312 | ### สร้าง etcd Server Key Pair
313 | ```
314 | {
315 | ETCD_HOSTNAMES=etcd0,etcd1,etcd2
316 | 
317 | cat > etcd-server-csr.json <<EOF
318 | {
319 |   "CN": "etcd-server",
320 |   "key": {
321 |     "algo": "rsa",
322 |     "size": 2048
323 |   },
324 |   "names": [
325 |     {
326 |       "C": "TH",
327 |       "O": "Kubernetes",
328 |       "OU": "Kubernetes The Hard Way CentOS",
329 |       "ST": "Bangkok"
330 |     }
331 |   ]
332 | }
333 | EOF
334 | 
335 | cfssl gencert \
336 |   -ca=ca.pem \
337 |   -ca-key=ca-key.pem \
338 |   -config=ca-config.json \
339 |   -hostname=192.168.254.61,192.168.254.62,192.168.254.63,127.0.0.1,${ETCD_HOSTNAMES} \
340 |   -profile=kubernetes \
341 |   etcd-server-csr.json | cfssljson -bare etcd-server
342 | 
343 | mv etcd-server-key.pem etcd-server.key
344 | mv etcd-server.pem etcd-server.crt
345 | }
346 | ```
347 | **Next>** [สร้าง Kubernetes Configuration Files สำหรับ Authentication](03-generating-kubenetes-configuration-file.md)
348 | 
349 | **<Prev** [รายละเอียดในการติดตั้ง](01-prerequisites.md)
350 | 


--------------------------------------------------------------------------------
/docs/03-generating-kubenetes-configuration-file.md:
--------------------------------------------------------------------------------
  1 | # สร้าง Kubernetes Configuration Files สำหรับ Authentication
  2 | Kubernetes Configuration Files หรืออาจจะเรียกสั้น ๆ ว่า kubeconfig ใช้เพื่อให้ Client ระบุ Kubernetes API Server ว่า cluster ไหน IP อะไร ให้บริการ port อะไร ร่วมถึง CA Certicate ที่จะในตอนเชื่อมต่อแบบ TLS, ระบุ credential ในการเชื่อมต่อไปยัง Kubernetes API Server และสุดท้ายก็จะมี context ที่จะจับคู่ระหว่าง credential กับ cluster ว่าจะใช้ credentail ตัวไหน เชื่อมต่อไปยัง cluster ไหน 
  3 | ## Kubernetes Configuration Files ต้องสร้างกี่ไฟล์
  4 | จากหน้าที่ของ Kubernetes Configuration Files ในช่วงแรก ดังนั้นส่วนประกอบใดที่ต้องเชื่อมต่อกับ Kubernetes API Server ก็ต้องสร้าง Kubernetes Configuration Files เตรียมไว้
  5 | ![Kubernetes and TLS Information](https://github.com/rdamrong/Kubernetes-The-Hard-Way-CentOS/blob/master/images/kube-component.png)
  6 | 
  7 | 
  8 | ## สร้าง kubelet Kubernetes Configuration File
  9 | ```
 10 | LOADBALANCER_ADDRESS=192.168.254.60
 11 | {
 12 |   kubectl config set-cluster kubernetes-the-hard-way \
 13 |     --certificate-authority=ca.crt \
 14 |     --embed-certs=true \
 15 |     --server=https://${LOADBALANCER_ADDRESS}:6443 \
 16 |     --kubeconfig=node0.kubeconfig
 17 | 
 18 |   kubectl config set-credentials system:node:node0 \
 19 |     --client-certificate=node0.crt \
 20 |     --client-key=node0.key \
 21 |     --embed-certs=true \
 22 |     --kubeconfig=node0.kubeconfig
 23 | 
 24 |   kubectl config set-context default \
 25 |     --cluster=kubernetes-the-hard-way \
 26 |     --user=system:node:node0 \
 27 |     --kubeconfig=node0.kubeconfig
 28 | 
 29 |   kubectl config use-context default --kubeconfig=node0.kubeconfig
 30 | }
 31 | 
 32 | {
 33 |   kubectl config set-cluster kubernetes-the-hard-way \
 34 |     --certificate-authority=ca.crt \
 35 |     --embed-certs=true \
 36 |     --server=https://${LOADBALANCER_ADDRESS}:6443 \
 37 |     --kubeconfig=node1.kubeconfig
 38 | 
 39 |   kubectl config set-credentials system:node:node1 \
 40 |     --client-certificate=node1.crt \
 41 |     --client-key=node1.key \
 42 |     --embed-certs=true \
 43 |     --kubeconfig=node1.kubeconfig
 44 | 
 45 |   kubectl config set-context default \
 46 |     --cluster=kubernetes-the-hard-way \
 47 |     --user=system:node:node1 \
 48 |     --kubeconfig=node1.kubeconfig
 49 | 
 50 |   kubectl config use-context default --kubeconfig=node1.kubeconfig
 51 | }
 52 | ```
 53 | ## สร้าง kube-proxy Kubernetes Configuration File
 54 | ```
 55 | LOADBALANCER_ADDRESS=192.168.254.60
 56 | kubectl config set-cluster kubernetes-the-hard-way \
 57 |     --certificate-authority=ca.crt \
 58 |     --embed-certs=true \
 59 |     --server=https://${LOADBALANCER_ADDRESS}:6443 \
 60 |     --kubeconfig=kube-proxy.kubeconfig
 61 | 
 62 |   kubectl config set-credentials system:kube-proxy \
 63 |     --client-certificate=kube-proxy.crt \
 64 |     --client-key=kube-proxy.key \
 65 |     --embed-certs=true \
 66 |     --kubeconfig=kube-proxy.kubeconfig
 67 | 
 68 |   kubectl config set-context default \
 69 |     --cluster=kubernetes-the-hard-way \
 70 |     --user=system:kube-proxy \
 71 |     --kubeconfig=kube-proxy.kubeconfig
 72 | 
 73 |   kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig
 74 | ```
 75 | ## สร้าง kube-controller-manager Kubernetes Configuration File
 76 | ```
 77 | kubectl config set-cluster kubernetes-the-hard-way \
 78 |     --certificate-authority=ca.crt \
 79 |     --embed-certs=true \
 80 |     --server=https://127.0.0.1:6443 \
 81 |     --kubeconfig=kube-controller-manager.kubeconfig
 82 | 
 83 |   kubectl config set-credentials system:kube-controller-manager \
 84 |     --client-certificate=kube-controller-manager.crt \
 85 |     --client-key=kube-controller-manager.key \
 86 |     --embed-certs=true \
 87 |     --kubeconfig=kube-controller-manager.kubeconfig
 88 | 
 89 |   kubectl config set-context default \
 90 |     --cluster=kubernetes-the-hard-way \
 91 |     --user=system:kube-controller-manager \
 92 |     --kubeconfig=kube-controller-manager.kubeconfig
 93 | 
 94 |   kubectl config use-context default --kubeconfig=kube-controller-manager.kubeconfig
 95 | 
 96 | ```
 97 | ## สร้าง kube-scheduler Kubernetes Configuration File
 98 | ```
 99 | kubectl config set-cluster kubernetes-the-hard-way \
100 |     --certificate-authority=ca.crt \
101 |     --embed-certs=true \
102 |     --server=https://127.0.0.1:6443 \
103 |     --kubeconfig=kube-scheduler.kubeconfig
104 | 
105 |   kubectl config set-credentials system:kube-scheduler \
106 |     --client-certificate=kube-scheduler.crt \
107 |     --client-key=kube-scheduler.key \
108 |     --embed-certs=true \
109 |     --kubeconfig=kube-scheduler.kubeconfig
110 | 
111 |   kubectl config set-context default \
112 |     --cluster=kubernetes-the-hard-way \
113 |     --user=system:kube-scheduler \
114 |     --kubeconfig=kube-scheduler.kubeconfig
115 | 
116 |   kubectl config use-context default --kubeconfig=kube-scheduler.kubeconfig
117 | ```
118 | ## สร้าง admin Kubernetes Configuration File
119 | ```
120 | kubectl config set-cluster kubernetes-the-hard-way \
121 |     --certificate-authority=ca.crt \
122 |     --embed-certs=true \
123 |     --server=https://127.0.0.1:6443 \
124 |     --kubeconfig=admin.kubeconfig
125 | 
126 |   kubectl config set-credentials admin \
127 |     --client-certificate=admin.crt \
128 |     --client-key=admin.key \
129 |     --embed-certs=true \
130 |     --kubeconfig=admin.kubeconfig
131 | 
132 |   kubectl config set-context default \
133 |     --cluster=kubernetes-the-hard-way \
134 |     --user=admin \
135 |     --kubeconfig=admin.kubeconfig
136 | 
137 |   kubectl config use-context default --kubeconfig=admin.kubeconfig
138 | ```
139 | **Next>** [สร้าง Data Encryption Config และ Key](04-generating-data-encryption-key.md)
140 | 
141 | **<Prev** [แนวคิดในการสร้าง TLS Certicate ใน Kubernetes และ สร้าง Certificate Authority กับ TLS Certificate](02-generating-tls-certificate.md)
142 | 


--------------------------------------------------------------------------------
/docs/04-generating-data-encryption-key.md:
--------------------------------------------------------------------------------
 1 | # สร้าง Data Encryption Config และ Key
 2 | ข้อมูลที่ Kubernetes API Server เขียนข้อมูลเก็บไว้ใน etcd server ในการเรียกใช้งาน Kubernetes API Server สามารถกำหนดให้เข้ารหัสลับข้อมูลที่ถูกจัดเก็บได้ เพื่อป้องกันข้อผิดพลาดที่อาจจะมีการเข้าถึงข้อมูลที่ etcd server โดยตรง ดังนั้งจึงต้องสร้าง Key เพื่อใช้ในการเข้ารหัสลับ, เก็บ key ไว้ที่ object ที่ชื่อว่า EncryptionConfig และ กำหนดให้ kube-apiserver เรียกใช้ EncryptionConfig ด้วย option  `--encryption-provider-config`
 3 | ## สร้าง Key ที่ใช้ในการเข้ารหัส
 4 | ในการสร้าง Key จะใช้วิธีการอ่านข้อมูลจาก /dev/urandom และ encode ด้วย base64
 5 | ```
 6 | {
 7 | ENCRYPTION_KEY=$(head -c 32 /dev/urandom | base64)
 8 | }
 9 | ```
10 | ## สร้าง EncryptionConfig
11 | ```
12 | {
13 | cat > encryption-config.yaml <<EOF
14 | kind: EncryptionConfig
15 | apiVersion: v1
16 | resources:
17 |   - resources:
18 |       - secrets
19 |     providers:
20 |       - aescbc:
21 |           keys:
22 |             - name: key1
23 |               secret: ${ENCRYPTION_KEY}
24 |       - identity: {}
25 | EOF
26 | }
27 | ```
28 | **Next>** [เคล็ดไม่ลับ เล็ก ๆ น้อย ๆ](05-tip-n-trick.md)
29 | 
30 | **<Prev** [สร้าง Kubernetes Configuration Files สำหรับ Authentication](03-generating-kubenetes-configuration-file.md)
31 | 


--------------------------------------------------------------------------------
/docs/05-tip-n-trick.md:
--------------------------------------------------------------------------------
1 | # เคล็ดไม่ลับ เล็ก ๆ น้อย ๆ
2 | ในขั้นตอนของการตั้ง master node 3 เครื่อง หรือ worker node 2 เครื่อง ก็จะเป็นชุดคำสั่งเดียวกัน ที่ต้องทำซ้ำ ๆ กัน ผู้เขียนจะติดตั้ง tmux แล้วเปิด 3 หรือ 2 pane เพื่อ remote access ไปยัง Virtual Machine แล้ว จากนั้นกด PREFIX + :setw synchronize-panes on จะทำให้เราพิมพ์คำสั่งครั้งเดียว เพื่อสั่งไปยัง Virtual Machine ได้
3 | ![screehshot](https://github.com/rdamrong/Kubernetes-The-Hard-Way-CentOS/blob/master/images/ss1.png)
4 | **Next>** [โอนถ่ายไฟล์ที่สร้างไปยัง Virtual Machine](06-transfer-file.md)
5 | 
6 | **<Prev** [สร้าง Data Encryption Config และ Key](04-generating-data-encryption-key.md)
7 | 


--------------------------------------------------------------------------------
/docs/06-transfer-file.md:
--------------------------------------------------------------------------------
 1 | # โอนถ่ายไฟล์ที่สร้างไปยัง Virtual Machine
 2 | ในขั้นตอนที่จะโอนถ่ายไฟล์ที่ถูกสร้างเตรียมไว้ ไปยัง Virtual Machine ตามหน้าที่ และความจำเป็นต้องใช้งาน
 3 | ```
 4 | for i in 192.168.254.61 192.168.254.62 192.168.254.63; do
 5 |     echo "Copy certificates and keys to $i" 
 6 |     scp admin.key admin.crt ca.crt ca.key kube-apiserver.key kube-apiserver.crt \
 7 |     service-account.key service-account.crt etcd-server.key etcd-server.crt \
 8 |     encryption-config.yaml admin.kubeconfig kube-controller-manager.kubeconfig \
 9 |     kube-scheduler.kubeconfig root@${i}:~/
10 | done
11 | 
12 | for i in 192.168.254.64 192.168.254.65; do
13 |     echo "Copy kube-proxy.kubeconfig to $i"
14 |     scp kube-proxy.kubeconfig root@${i}:~/
15 | done
16 | 
17 | scp ca.crt node0.crt node0.key node0.kubeconfig root@192.168.254.64:~/
18 | scp ca.crt node1.crt node1.key node1.kubeconfig root@192.168.254.65:~/
19 | ```
20 | **Next>** [ติดตั้ง etcd](07-install_etcd_cluster.md)
21 | 
22 | **<Prev** [เคล็ดไม่ลับ เล็ก ๆ น้อย ๆ](05-tip-n-trick.md)
23 | 


--------------------------------------------------------------------------------
/docs/07-install_etcd_cluster.md:
--------------------------------------------------------------------------------
 1 | # ติดตั้ง etcd
 2 | 
 3 | etcd ทำหน้าที่เก็บข้อมูลต่าง ๆ ของ cluster ไม่ว่าจะเป็นข้อมูลของ cluster เอง และข้อมูลสถานะขณะที่ Kubernetes กำลังทำงาน ในเอกสารชุดนี้ etcd จะถูกติดตั้งที่ master node และกำหนดค่าให้ etcd ทำงานในรูปแบบ High Availability และคำนึงถึงความปลอดภัยในการเชื่อมต่อ หากต้องการข้อมูลเพิ่มเติมได้ที่ [etcd](https://github.com/etcd-io/etcd)
 4 | 
 5 | 
 6 | ## เตรียม etcd binaries [all master node]
 7 | ```
 8 | {
 9 | ETCD_VER=v3.4.13
10 | DOWNLOAD_URL=https://storage.googleapis.com/etcd
11 | 
12 | curl -L ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz -o etcd-${ETCD_VER}-linux-amd64.tar.gz
13 | tar xzvf etcd-${ETCD_VER}-linux-amd64.tar.gz
14 | mv etcd-${ETCD_VER}-linux-amd64/etcd* /usr/local/bin
15 | /usr/local/bin/etcd --version
16 | ETCDCTL_API=3 /usr/local/bin/etcdctl version
17 | }
18 | ```
19 | ## เตรียม directory และ key pair ที่ใช้ในการทำงานของ etcd [all master node]
20 | ```
21 | {
22 | mkdir -p /etc/etcd /var/lib/etcd
23 |  chmod 700 /var/lib/etcd 
24 |  cp ca.crt etcd-server.key etcd-server.crt /etc/etcd/
25 | }
26 | ```
27 | ## เตรียมตัวแปรสำหรับสร้าง `etcd.service` [all master node]
28 | ```
29 | {
30 | INTERNAL_IP=$(ip addr show eth0 | grep "inet " | awk '{print $2}' | cut -d / -f 1)
31 | ETCD_NAME=$(hostname -s)
32 | echo $INTERNAL_IP $ETCD_NAME
33 | }
34 | ```
35 | > eth0 เป็นชื่อ network interface card ซึ่งอาจจะต่างกันไป
36 | ## สร้าง `etcd.service` สำหรับ systemd [all master node]
37 | ```
38 | {
39 | cat <<EOF | sudo tee /etc/systemd/system/etcd.service
40 | [Unit]
41 | Description=etcd
42 | Documentation=https://github.com/coreos
43 | 
44 | [Service]
45 | ExecStart=/usr/local/bin/etcd \\
46 |  --name ${ETCD_NAME} \\
47 |  --cert-file=/etc/etcd/etcd-server.crt \\
48 |  --key-file=/etc/etcd/etcd-server.key \\
49 |  --peer-cert-file=/etc/etcd/etcd-server.crt \\
50 |  --peer-key-file=/etc/etcd/etcd-server.key \\
51 |  --trusted-ca-file=/etc/etcd/ca.crt \\
52 |  --peer-trusted-ca-file=/etc/etcd/ca.crt \\
53 |  --peer-client-cert-auth \\
54 |  --client-cert-auth \\
55 |  --initial-advertise-peer-urls https://${INTERNAL_IP}:2380 \\
56 |  --listen-peer-urls https://${INTERNAL_IP}:2380 \\
57 |  --listen-client-urls https://${INTERNAL_IP}:2379,https://127.0.0.1:2379 \\
58 |  --advertise-client-urls https://${INTERNAL_IP}:2379 \\
59 |  --initial-cluster-token etcd-cluster-0 \\
60 |  --initial-cluster master0=https://192.168.254.61:2380,master1=https://192.168.254.62:2380,master2=https://192.168.254.63:2380 \\
61 |  --initial-cluster-state new \\
62 |  --data-dir=/var/lib/etcd
63 | Restart=on-failure
64 | RestartSec=5
65 | 
66 | [Install]
67 | WantedBy=multi-user.target
68 | EOF
69 | }
70 | ```
71 | ## เริ่มการทำงานของ etcd [all master node]
72 | ```
73 | {
74 |  systemctl daemon-reload
75 |  systemctl enable --now etcd
76 | }
77 | ```
78 | 
79 | 
80 | ## ทดสอบการทำงานของ etcd [all master node]
81 | ```
82 | ETCDCTL_API=3 etcdctl member list \
83 |  --endpoints=https://127.0.0.1:2379 \
84 |  --cacert=/etc/etcd/ca.crt \
85 |  --cert=/etc/etcd/etcd-server.crt \
86 |  --key=/etc/etcd/etcd-server.key
87 |  ```
88 |  > ผลการทดสอบ
89 |  ```
90 | 41cf2dc7f859bfed, started, master2, https://192.168.254.63:2380, https://192.168.254.63:2379, false
91 | 8283bd82ad10dcb8, started, master1, https://192.168.254.62:2380, https://192.168.254.62:2379, false
92 | fcae0ac3856fb516, started, master0, https://192.168.254.61:2380, https://192.168.254.61:2379, false
93 | ```
94 | **Next>** [ติดตั้ง Kubernetes Control Plane](08-install_kubernetes_control_plane.md)
95 | 
96 | **<Prev** [โอนถ่ายไฟล์ที่สร้างไปยัง Virtual Machine](06-transfer-file.md)
97 | 


--------------------------------------------------------------------------------
/docs/08-install_kubernetes_control_plane.md:
--------------------------------------------------------------------------------
  1 | # ติดตั้ง Kubernetes Control Plane
  2 | 
  3 | kube-apiserver, kube-controller-manager, kube-scheduler เป็นองค์ประกอบสำคัญของการทำงานของ master node และติดตั้ง kubectl ที่เป็น Kubenetes Client ที่จะเชื่อมต่อกับ Kubenetes Cluster ในเบื้องต้นเพื่อสร้างส่วนที่จำเป็นภายใน Kubernetes Cluster 
  4 | ## เตรียม Kubenetes Controller binaries [all master node]
  5 | ```
  6 | {
  7 | KUBEVER=v1.19.2
  8 | DL=https://dl.k8s.io/${KUBEVER}/kubernetes-server-linux-amd64.tar.gz
  9 | 
 10 | dnf install -y wget
 11 | wget -q --show-progress ${DL}
 12 | 
 13 | tar xvfz kubernetes-server-linux-amd64.tar.gz
 14 | cd kubernetes/server/bin/
 15 | mv kube-apiserver kube-controller-manager kube-scheduler kubectl /usr/local/bin/
 16 | cd
 17 | }
 18 | ```
 19 | ## เตรียม directory, key pair และข้อมูลที่ใช้ในการทำงานของ Kubernetes Controller [all master node]
 20 | ```
 21 | mkdir -p /etc/kubernetes/config
 22 | mkdir -p /var/lib/kubernetes/
 23 | cp ca.crt ca.key kube-apiserver.crt kube-apiserver.key \
 24 |    service-account.key service-account.crt \
 25 |    etcd-server.key etcd-server.crt \
 26 |    encryption-config.yaml /var/lib/kubernetes/
 27 | cp kube-controller-manager.kubeconfig /var/lib/kubernetes/
 28 | cp kube-scheduler.kubeconfig /var/lib/kubernetes/
 29 | INTERNAL_IP=$(ip addr show eth0| grep "inet " | awk '{print $2}' | cut -d / -f 1)
 30 | echo $INTERNAL_IP
 31 | ```
 32 | > eth0 เป็นชื่อ network interface card ซึ่งอาจจะต่างกันไป
 33 | ## สร้าง `kube-apiserver.service` สำหรับ systemd [all master node]
 34 | ```
 35 | cat <<EOF | sudo tee /etc/systemd/system/kube-apiserver.service
 36 | [Unit]
 37 | Description=Kubernetes API Server
 38 | Documentation=https://github.com/kubernetes/kubernetes
 39 | 
 40 | [Service]
 41 | ExecStart=/usr/local/bin/kube-apiserver \\
 42 |  --advertise-address=${INTERNAL_IP} \\
 43 |  --allow-privileged=true \\
 44 |  --apiserver-count=3 \\
 45 |  --audit-log-maxage=30 \\
 46 |  --audit-log-maxbackup=3 \\
 47 |  --audit-log-maxsize=100 \\
 48 |  --audit-log-path=/var/log/audit.log \\
 49 |  --authorization-mode=Node,RBAC \\
 50 |  --bind-address=0.0.0.0 \\
 51 |  --client-ca-file=/var/lib/kubernetes/ca.crt \\
 52 |  --enable-admission-plugins=NamespaceLifecycle,NodeRestriction,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota \\
 53 |  --enable-bootstrap-token-auth=true \\
 54 |  --etcd-cafile=/var/lib/kubernetes/ca.crt \\
 55 |  --etcd-certfile=/var/lib/kubernetes/etcd-server.crt \\
 56 |  --etcd-keyfile=/var/lib/kubernetes/etcd-server.key \\
 57 |  --etcd-servers=https://192.168.254.61:2379,https://192.168.254.62:2379,https://192.168.254.63:2379 \\
 58 |  --event-ttl=1h \\
 59 |  --encryption-provider-config=/var/lib/kubernetes/encryption-config.yaml \\
 60 |  --kubelet-certificate-authority=/var/lib/kubernetes/ca.crt \\
 61 |  --kubelet-client-certificate=/var/lib/kubernetes/kube-apiserver.crt \\
 62 |  --kubelet-client-key=/var/lib/kubernetes/kube-apiserver.key \\
 63 |  --kubelet-https=true \\
 64 |  --runtime-config='api/all=true' \\
 65 |  --service-account-key-file=/var/lib/kubernetes/service-account.crt \\
 66 |  --service-cluster-ip-range=10.96.0.0/24 \\
 67 |  --service-node-port-range=30000-32767 \\
 68 |  --tls-cert-file=/var/lib/kubernetes/kube-apiserver.crt \\
 69 |  --tls-private-key-file=/var/lib/kubernetes/kube-apiserver.key \\
 70 |  --v=2
 71 | Restart=on-failure
 72 | RestartSec=5
 73 | 
 74 | [Install]
 75 | WantedBy=multi-user.target
 76 | EOF
 77 | ```
 78 | ## สร้าง `kube-controller-manager.service` สำหรับ systemd [all master node]
 79 | ```
 80 | cat <<EOF | sudo tee /etc/systemd/system/kube-controller-manager.service
 81 | [Unit]
 82 | Description=Kubernetes Controller Manager
 83 | Documentation=https://github.com/kubernetes/kubernetes
 84 | 
 85 | [Service]
 86 | ExecStart=/usr/local/bin/kube-controller-manager \\
 87 |  --address=0.0.0.0 \\
 88 |  --cluster-cidr=192.168.254.0/24 \\
 89 |  --cluster-name=kubernetes \\
 90 |  --cluster-signing-cert-file=/var/lib/kubernetes/ca.crt \\
 91 |  --cluster-signing-key-file=/var/lib/kubernetes/ca.key \\
 92 |  --kubeconfig=/var/lib/kubernetes/kube-controller-manager.kubeconfig \\
 93 |  --leader-elect=true \\
 94 |  --root-ca-file=/var/lib/kubernetes/ca.crt \\
 95 |  --service-account-private-key-file=/var/lib/kubernetes/service-account.key \\
 96 |  --service-cluster-ip-range=10.96.0.0/24 \\
 97 |  --use-service-account-credentials=true \\
 98 |  --v=2
 99 | Restart=on-failure
100 | RestartSec=5
101 | 
102 | [Install]
103 | WantedBy=multi-user.target
104 | EOF
105 | ```
106 | ## สร้าง `kube-scheduler.service` สำหรับ systemd [all master node]
107 | ```
108 | cat <<EOF | sudo tee /etc/kubernetes/config/kube-scheduler.yaml
109 | apiVersion: kubescheduler.config.k8s.io/v1beta1
110 | kind: KubeSchedulerConfiguration
111 | clientConnection:
112 |   kubeconfig: "/var/lib/kubernetes/kube-scheduler.kubeconfig"
113 | leaderElection:
114 |   leaderElect: true
115 | EOF
116 | 
117 | cat <<EOF | sudo tee /etc/systemd/system/kube-scheduler.service
118 | [Unit]
119 | Description=Kubernetes Scheduler
120 | Documentation=https://github.com/kubernetes/kubernetes
121 | 
122 | [Service]
123 | ExecStart=/usr/local/bin/kube-scheduler \\
124 |   --config=/etc/kubernetes/config/kube-scheduler.yaml \\
125 |   --v=2
126 | Restart=on-failure
127 | RestartSec=5
128 | 
129 | [Install]
130 | WantedBy=multi-user.target
131 | EOF
132 | ```
133 | ## เริ่มการทำงานของ kube-apiserver, kube-controller-manager และ kube-scheduler [all master node]
134 | ```
135 | systemctl daemon-reload
136 | systemctl enable --now   kube-apiserver kube-controller-manager kube-scheduler
137 | ```
138 | ## ทดสอบและผลทดสอบของ kube-apiserver [all master node]
139 | ```
140 | kubectl get --raw='/readyz?verbose' --kubeconfig=admin.kubeconfig
141 | ```
142 | > ผลการทดสอบ
143 | ```
144 | [+]ping ok
145 | [+]log ok
146 | [+]etcd ok
147 | [+]informer-sync ok
148 | [+]poststarthook/start-kube-apiserver-admission-initializer ok
149 | [+]poststarthook/generic-apiserver-start-informers ok
150 | [+]poststarthook/start-apiextensions-informers ok
151 | [+]poststarthook/start-apiextensions-controllers ok
152 | [+]poststarthook/crd-informer-synced ok
153 | [+]poststarthook/bootstrap-controller ok
154 | [+]poststarthook/rbac/bootstrap-roles ok
155 | [+]poststarthook/scheduling/bootstrap-system-priority-classes ok
156 | [+]poststarthook/priority-and-fairness-config-producer ok
157 | [+]poststarthook/start-cluster-authentication-info-controller ok
158 | [+]poststarthook/start-kube-aggregator-informers ok
159 | [+]poststarthook/apiservice-registration-controller ok
160 | [+]poststarthook/apiservice-status-available-controller ok
161 | [+]poststarthook/kube-apiserver-autoregistration ok
162 | [+]autoregister-completion ok
163 | [+]poststarthook/apiservice-openapi-controller ok
164 | [+]shutdown ok
165 | healthz check passed
166 | ```
167 | **Next>** [ติดตั้ง Loadbalancer สำหรับ master node](09-loadbalancer.md)
168 | 
169 | **<Prev** [ติดตั้ง etcd](07-install_etcd_cluster.md)
170 | 


--------------------------------------------------------------------------------
/docs/09-loadbalancer.md:
--------------------------------------------------------------------------------
 1 | # ติดตั้ง Loadbalancer สำหรับ master node
 2 | master node แต่ละตัวถูกออกแบบให้สามารถทำงานแยกกันได้อย่างอิสระ ผู้ใช้งาน Kubernetes Cluster สามารถเชื่อมต่อไปใช้งานที่ master node ตัวไหนก็ได้ ดังนั้นเพื่อให้สะดวกกับการเชื่อมต่อไปยัง master node จึงนิยมให้มี loadbalancer ทำหน้าที่จัดการ loadbalancer ไปยัง master node แต่ละตัว ซึ่งผู้เขียนเลือกใช้ NGINX มาทำหน้าที่เป็น loadbalancer
 3 | 
 4 | ## ขั้นตอนการติดตั้ง NGINX [loadbalancer node]
 5 | ```
 6 | yum install -y nginx
 7 | echo " 
 8 | stream{
 9 |   upstream kubernetes {
10 |       server 192.168.254.61:6443;
11 |       server 192.168.254.62:6443;
12 |       server 192.168.254.63:6443;
13 |   }
14 |   server {
15 |       listen 6443;
16 |       proxy_pass kubernetes;
17 |   }
18 | }
19 | " >> /etc/nginx/nginx.conf
20 | systemctl enable --now nginx
21 | ```
22 | **Next>** [ติดตั้ง Kubernetes Worker Nodes](10-install-worker-node.md)
23 | 
24 | **<Prev** [ติดตั้ง Kubernetes Control Plane](08-install_kubernetes_control_plane.md)
25 | 


--------------------------------------------------------------------------------
/docs/10-install-worker-node.md:
--------------------------------------------------------------------------------
  1 | # ติดตั้ง Kubernetes Worker Nodes
  2 | kubelet และ kube-proxy เป็นส่วนประกอบ 2 ส่วนของ Kubernetes ที่ติดตั้งที่ Worker Node ที่ใช้ในการจัดการสิ่งต่าง ๆ ที่เกิดขี้นใน Cluster และยังต้องสื่อสารกับ master node ตลอดเวลา นอกเหนือจาก นั้นก็มี Container Runtime อีกด้วย 
  3 | ## เตรียม Kubernetes Worker Node Binaries [all worker node]
  4 | ```
  5 | KUBEVER=v1.19.2
  6 | 
  7 | mkdir -p \
  8 |  /etc/cni/net.d \
  9 |  /opt/cni/bin \
 10 |  /var/lib/kubelet \
 11 |  /var/lib/kube-proxy \
 12 |  /var/lib/kubernetes \
 13 |  /var/run/kubernetes
 14 | 
 15 | dnf install -y wget
 16 | wget --show-progress https://dl.k8s.io/${KUBEVER}/kubernetes-node-linux-amd64.tar.gz
 17 | 
 18 | tar xvfz kubernetes-node-linux-amd64.tar.gz
 19 | cd kubernetes/node/bin/
 20 | mv kubectl kube-proxy kubelet /usr/local/bin/
 21 | cd
 22 | ```
 23 | ## เตรียมข้อมูลที่ใช้ในการทำงานของ kubelet [all worker node]
 24 | ```
 25 | cp ${HOSTNAME}.key ${HOSTNAME}.crt /var/lib/kubelet/
 26 | cp ${HOSTNAME}.kubeconfig /var/lib/kubelet/kubeconfig
 27 | cp ca.crt /var/lib/kubernetes/
 28 | 
 29 | cat <<EOF | sudo tee /var/lib/kubelet/kubelet-config.yaml
 30 | kind: KubeletConfiguration
 31 | apiVersion: kubelet.config.k8s.io/v1beta1
 32 | authentication:
 33 |   anonymous:
 34 |     enabled: false
 35 |   webhook:
 36 |     enabled: true
 37 |   x509:
 38 |     clientCAFile: "/var/lib/kubernetes/ca.crt"
 39 | authorization:
 40 |   mode: Webhook
 41 | clusterDomain: "cluster.local"
 42 | clusterDNS:
 43 |   - "10.96.0.10"
 44 | resolvConf: "/etc/resolv.conf"
 45 | runtimeRequestTimeout: "15m"
 46 | tlsCertFile: "/var/lib/kubelet/${HOSTNAME}.crt"
 47 | tlsPrivateKeyFile: "/var/lib/kubelet/${HOSTNAME}.key"
 48 | EOF
 49 | ```
 50 | ## สร้าง kubelet.service สำหรับ systemd [all worker node]
 51 | ```
 52 | cat <<EOF | sudo tee /etc/systemd/system/kubelet.service
 53 | [Unit]
 54 | Description=Kubernetes Kubelet
 55 | Documentation=https://github.com/kubernetes/kubernetes
 56 | After=docker.service
 57 | Requires=docker.service
 58 | 
 59 | [Service]
 60 | ExecStart=/usr/local/bin/kubelet \\
 61 |   --config=/var/lib/kubelet/kubelet-config.yaml \\
 62 |   --image-pull-progress-deadline=2m \\
 63 |   --kubeconfig=/var/lib/kubelet/kubeconfig \\
 64 |   --tls-cert-file=/var/lib/kubelet/${HOSTNAME}.crt \\
 65 |   --tls-private-key-file=/var/lib/kubelet/${HOSTNAME}.key \\
 66 |   --network-plugin=cni \\
 67 |   --register-node=true \\
 68 |   --v=2
 69 | Restart=on-failure
 70 | RestartSec=5
 71 | 
 72 | [Install]
 73 | WantedBy=multi-user.target
 74 | EOF
 75 | ```
 76 | ## เตรียมข้อมูลที่ใช้ในการทำงานของ kube-proxy [all worker node]
 77 | ```
 78 | cp kube-proxy.kubeconfig /var/lib/kube-proxy/kubeconfig
 79 | cat <<EOF | sudo tee /var/lib/kube-proxy/kube-proxy-config.yaml
 80 | kind: KubeProxyConfiguration
 81 | apiVersion: kubeproxy.config.k8s.io/v1alpha1
 82 | clientConnection:
 83 |   kubeconfig: "/var/lib/kube-proxy/kubeconfig"
 84 | mode: "iptables"
 85 | clusterCIDR: "10.0.0.0/16"
 86 | EOF
 87 | ```
 88 | ## สร้าง kube-proxy.service สำหรับ systemd [all worker node]
 89 | ```
 90 | cat <<EOF | sudo tee /etc/systemd/system/kube-proxy.service
 91 | [Unit]
 92 | Description=Kubernetes Kube Proxy
 93 | Documentation=https://github.com/kubernetes/kubernetes
 94 | 
 95 | [Service]
 96 | ExecStart=/usr/local/bin/kube-proxy \\
 97 |   --config=/var/lib/kube-proxy/kube-proxy-config.yaml
 98 | Restart=on-failure
 99 | RestartSec=5
100 | 
101 | [Install]
102 | WantedBy=multi-user.target
103 | EOF
104 | ```
105 | ## เริ่มการทำงานของ kubelet และ kube-proxy [all worker node]
106 | ```
107 | systemctl daemon-reload
108 | systemctl enable kubelet kube-proxy --now
109 | ```
110 | ## ทดสอบและผลการทดสอบ [master0]
111 | ```
112 | kubectl get nodes --kubeconfig admin.kubeconfig
113 | ```
114 | >ผลการทดสอบ
115 | ```
116 | NAME    STATUS     ROLES    AGE    VERSION
117 | node0   NotReady   <none>   10m    v1.19.0
118 | node1   NotReady   <none>   6m7s   v1.19.0
119 | ```
120 | > ผลที่ได้ สถานะของ node จะยังเป็น Not Ready เนื่องจาก ในส่วนของ Network ยังไม่ได้ถูกกำหนดค่า
121 | 
122 | **Next>** [Kubernetes Object Authorization](11-kubernetes-object-authorization.md)
123 | 
124 | **<Prev** [ติดตั้ง Loadbalancer สำหรับ master node](09-loadbalancer.md)
125 | 


--------------------------------------------------------------------------------
/docs/11-kubernetes-object-authorization.md:
--------------------------------------------------------------------------------
 1 | # กำหนดค่า Kubernetes Object Authorization
 2 | ภายใน Kubernetes Cluster เองก็มีการควบคุมการเข้าถึงในแต่ละส่วนด้วยแนวคิด RBAC (Role-Based Access Control) ดังนั้นในการใช้งานจำเป็นต้องกำหนดให้ object ตัวไหน สามารถใช้งาน object ตัวไหนได้บ้าง ในเอกสารนี้จะกำหนดให้ Kubernetes API Server สามารถเข้าถึงข้อมูลบางส่วนของ Kubelet ในบทบาทของ system:kubelet-api-admin
 3 | ## กำหนดให้ผู้ใช้ชื่อ kubernetes มีสิทธิ์ในบทบาท system:kubelet-api-admin [master0]
 4 | ```
 5 | {
 6 | cat <<EOF | kubectl apply --kubeconfig admin.kubeconfig -f -
 7 | apiVersion: rbac.authorization.k8s.io/v1
 8 | kind: ClusterRoleBinding
 9 | metadata:
10 |   name: apiserver-kubelet-api-admin
11 | roleRef:
12 |   apiGroup: rbac.authorization.k8s.io
13 |   kind: ClusterRole
14 |   name: system:kubelet-api-admin
15 | subjects:
16 | - apiGroup: rbac.authorization.k8s.io
17 |   kind: User
18 |   name: kubernetes
19 | EOF
20 | }
21 | ```
22 | **Next>** [สร้าง kubeconfig สำหรับ remote access](12-kubectl-remote-access.md)
23 | 
24 | **<Prev** [ติดตั้ง Kubernetes Worker Nodes](10-install-worker-node.md)
25 | 


--------------------------------------------------------------------------------
/docs/12-kubectl-remote-access.md:
--------------------------------------------------------------------------------
 1 | # สร้าง Kubernetes Configuration File สำหรับ remote access
 2 | จากที่ผ่านมาใช้จะส่งค่า kubeconfig file ผ่าน option --kubeconfig กับ kubectl ในเอกสารฉบับนี้จะสร้าง kubeconfig file ให้อยู่ในตำแหน่งที่เป็น default ที่ไม่จำเป็นต้องระบุ -kubeconfig ซึ่งไฟล์นั้นจะถูกเก็บไว้ที่ $HOME/.kube/config ซึ่งสามารถสร้างที่ไหนก็ได้ที่สามารถติดตั้ง kubectl ได้ ไม่จำเป็นต้องสร้างหรือใช้งานจากภายใน Kubernetes Cluster 
 3 | ```
 4 | {
 5 |   KUBERNETES_LB_ADDRESS=192.168.254.60
 6 | 
 7 |   kubectl config set-cluster kubernetes-the-hard-way \
 8 |     --certificate-authority=ca.crt \
 9 |     --embed-certs=true \
10 |     --server=https://${KUBERNETES_LB_ADDRESS}:6443
11 | 
12 |   kubectl config set-credentials admin \
13 |     --client-certificate=admin.crt \
14 |     --client-key=admin.key
15 | 
16 |   kubectl config set-context kubernetes-the-hard-way \
17 |     --cluster=kubernetes-the-hard-way \
18 |     --user=admin
19 | 
20 |   kubectl config use-context kubernetes-the-hard-way
21 | }
22 | ```
23 | **Next>** [ติดตั้ง Network สำหรับ Pod](13-pod-network.md)
24 | 
25 | **<Prev** [Kubernetes Object Authorization](11-kubernetes-object-authorization.md)
26 | 


--------------------------------------------------------------------------------
/docs/13-pod-network.md:
--------------------------------------------------------------------------------
 1 | # ติดตั้ง Network สำหรับ Pod
 2 | ในการเชื่อมต่อผ่าน network ของ pod ภายใน cluster มีหลายตัวเลือกให้เลือกใช้ ในเอกสารนี้เลือก [weave](https://www.weave.works/docs/net/latest/kubernetes/kube-addon/) เป็นตัวอย่างในการติดตั้ง ซี่งต้องทำงานร่วมกัน Container Network Interface (CNI)
 3 | ## ติดตั้ง Container Network Interface (CNI) [all worker node]
 4 | ```
 5 | wget https://github.com/containernetworking/plugins/releases/download/v0.8.7/cni-plugins-linux-amd64-v0.8.7.tgz
 6 | tar xvfz cni-plugins-linux-amd64-v0.8.7.tgz  --directory /opt/cni/bin
 7 | ```
 8 | ## ติดตั้ง weave [master0]
 9 | ```
10 | kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
11 | ```
12 | ## ตรวจสอบการติดตั้ง weave [master0]
13 | ```
14 | kubectl get pods -n kube-system
15 | ```
16 | > ผลการทดสอบ
17 | ```
18 | NAME              READY   STATUS    RESTARTS   AGE
19 | weave-net-c8wgm   1/2     Running   0          35s
20 | weave-net-lxwpn   1/2     Running   0          35s
21 | ```
22 | > จะพบว่ามี pod ที่ชื่อว่า weave-net-xxxxx ที่มีสถานะ Running ทำงานอยู่
23 | ## ตรวจสอบสถานะของ Worker Node [master0]
24 | ```
25 | kubectl get nodes
26 | ```
27 | > ผลการทดสอบ
28 | ```
29 | NAME    STATUS   ROLES    AGE   VERSION
30 | node0   Ready    <none>   14m   v1.19.0
31 | node1   Ready    <none>   11m   v1.19.0
32 | ```
33 | **Next>** [ติดตั้ง DNS สำหรับ Services และ Pods](14-dns-for-services-and-pods.md)
34 | 
35 | **<Prev** [สร้าง kubeconfig สำหรับ remote access](12-kubectl-remote-access.md)
36 | 


--------------------------------------------------------------------------------
/docs/14-dns-for-services-and-pods.md:
--------------------------------------------------------------------------------
 1 | # ติดตั้ง DNS สำหรับ Services และ Pods
 2 | ทุก services ที่ถูกสร้างภายใน Cluster จะได้มีชื่อนั้นถูกกำหนดใน DNS เช่นกัน ทำให้สามาถใช้ชื่อในการอ้างถึง service ได้โดยมีรูปแบบ `servicename.namespace.svc.cluster.local` ในเอกสารชุดนี้จะใช้ [CoreDNS](https://coredns.io/) ทำหน้าที่นี้
 3 | 
 4 | ## ติดตั้ง CoreDNS [master0]
 5 | ```
 6 | dnf install -y git jq
 7 | git clone https://github.com/coredns/deployment.git
 8 | cd deployment/kubernetes/
 9 | ./deploy.sh -i 10.96.0.10 | kubectl apply -f -
10 | ```
11 | ### ตรวจสอบการติดตั้งของ CoreDNS [master0]
12 | ```
13 | kubectl get pods -n kube-system
14 | ```
15 | > ผลการทดสอบ จะพบ pod ชื่อว่า coredns-xxxxxxxxxx-xxxxx สถานะ Running อยู่
16 | ```
17 | NAME                       READY   STATUS    RESTARTS   AGE
18 | coredns-7bf4bd64bd-zgtnf   1/1     Running   0          14s
19 | weave-net-c8wgm            2/2     Running   0          3m39s
20 | weave-net-lxwpn            2/2     Running   0          3m39s
21 | ```
22 | > จะพบว่ามี pod ที่ชื่อว่า coredns-xxxxxxxxxx-xxxxx สถานะ Running อยู่
23 | ### ทดสอบการทำงานของ CoreDNS [master0]
24 | ```
25 | ]#  kubectl run dnstest --image centos -- sleep 36000
26 | pod/dnstest created
27 | ]# kubectl get pods
28 | NAME      READY   STATUS    RESTARTS   AGE
29 | dnstest   1/1     Running   0          50s
30 | ]# kubectl exec -it dnstest -- /bin/bash
31 | [root@dnstest /]# yum install -y bind-utils
32 | [root@dnstest /]# dig kubernetes.default.svc.cluster.local
33 | 
34 | ; <<>> DiG 9.11.13-RedHat-9.11.13-6.el8_2.1 <<>> kubernetes.default.svc.cluster.local
35 | ;; global options: +cmd
36 | ;; Got answer:
37 | ;; WARNING: .local is reserved for Multicast DNS
38 | ;; You are currently testing what happens when an mDNS query is leaked to DNS
39 | ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 8809
40 | ;; flags: qr aa rd; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
41 | ;; WARNING: recursion requested but not available
42 | 
43 | ;; OPT PSEUDOSECTION:
44 | ; EDNS: version: 0, flags:; udp: 4096
45 | ; COOKIE: 1f618ef8f0a39ff7 (echoed)
46 | ;; QUESTION SECTION:
47 | ;kubernetes.default.svc.cluster.local. IN A
48 | 
49 | ;; ANSWER SECTION:
50 | kubernetes.default.svc.cluster.local. 5 IN A    10.96.0.1
51 | 
52 | ;; Query time: 0 msec
53 | ;; SERVER: 10.96.0.10#53(10.96.0.10)
54 | ;; WHEN: Wed Sep 23 15:04:06 UTC 2020
55 | ;; MSG SIZE  rcvd: 129
56 | 
57 | ```
58 | **Next>** [ทดสอบการทำงาน](15-test.md)
59 | 
60 | **<Prev** [ติดตั้ง Network สำหรับ Pod](13-pod-network.md)
61 | 


--------------------------------------------------------------------------------
/docs/15-test.md:
--------------------------------------------------------------------------------
  1 | # ทดสอบการทำงาน
  2 | ## ทดสอบ Pod Network
  3 | ```
  4 | [root@master0 ~]# kubectl get pods -o wide
  5 | NAME      READY   STATUS    RESTARTS   AGE   IP          NODE    NOMINATED NODE   READINESS GATES
  6 | dnstest   1/1     Running   0          9m    10.32.0.2   node1   <none>           <none>
  7 | 
  8 | 
  9 | [root@master0 ~]# kubectl run pingtest -it --image centos -- /bin/bash
 10 | If you don't see a command prompt, try pressing enter.
 11 | 
 12 | [root@pingtest /]# ping -c 3 10.32.0.2
 13 | PING 10.32.0.2 (10.32.0.2) 56(84) bytes of data.
 14 | 64 bytes from 10.32.0.2: icmp_seq=1 ttl=64 time=1.49 ms
 15 | 64 bytes from 10.32.0.2: icmp_seq=2 ttl=64 time=0.666 ms
 16 | 64 bytes from 10.32.0.2: icmp_seq=3 ttl=64 time=0.699 ms
 17 | 
 18 | --- 10.32.0.2 ping statistics ---
 19 | 3 packets transmitted, 3 received, 0% packet loss, time 17ms
 20 | rtt min/avg/max/mdev = 0.666/0.952/1.493/0.383 ms
 21 | 
 22 | 
 23 | [root@pingtest /]# exit
 24 | exit
 25 | Session ended, resume using 'kubectl attach pingtest -c pingtest -i -t' command when the pod is running
 26 | ```
 27 | ## ทดสอบสร้าง Deployment
 28 | ```
 29 | [root@master0 ~]# echo "
 30 | apiVersion: apps/v1
 31 | kind: Deployment
 32 | metadata:
 33 |   name: dp1
 34 | spec:
 35 |   replicas: 5
 36 |   selector:
 37 |     matchLabels:
 38 |        run: dp-hello
 39 |   template:
 40 |     metadata:
 41 |       name: my-app
 42 |       labels:
 43 |         run: dp-hello
 44 |     spec:
 45 |       containers:
 46 |         - name: my-hello
 47 |           image: nginxdemos/nginx-hello:plain-text
 48 | " | kubectl apply -f -
 49 | 
 50 | 
 51 | [root@master0 ~]# kubectl get pods
 52 | NAME                   READY   STATUS    RESTARTS   AGE
 53 | dnstest                1/1     Running   0          17m
 54 | dp1-6fc549dc58-4l686   1/1     Running   0          9s
 55 | dp1-6fc549dc58-8pj9v   1/1     Running   0          9s
 56 | dp1-6fc549dc58-rd7hp   1/1     Running   0          9s
 57 | dp1-6fc549dc58-trcf8   1/1     Running   0          9s
 58 | dp1-6fc549dc58-vgb5d   1/1     Running   0          9s
 59 | pingtest               1/1     Running   1          8m29s
 60 | ```
 61 | ## ทดสอบสร้าง Service แบบ NodePort
 62 | ```
 63 | [root@master0 ~]# echo "
 64 | apiVersion: v1
 65 | kind: Service
 66 | metadata:
 67 |   name: svc-np
 68 | spec:
 69 |   type: NodePort
 70 |   selector:
 71 |     run: dp-hello
 72 |   ports:
 73 |     - port: 9090
 74 |       protocol: TCP
 75 |       targetPort: 8080
 76 |       nodePort: 31111
 77 | " |  kubectl apply -f -
 78 | 
 79 | 
 80 | [root@master0 ~]# kubectl get services
 81 | NAME         TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)          AGE
 82 | kubernetes   ClusterIP   10.96.0.1     <none>        443/TCP          34m
 83 | svc-np       NodePort    10.96.0.178   <none>        9090:31111/TCP   9s
 84 | 
 85 | 
 86 | [root@master0 ~]# curl http://node0.example.com:31111
 87 | Server address: 10.44.0.3:8080
 88 | Server name: dp1-6fc549dc58-rwmxr
 89 | Date: 23/Sep/2020:15:25:40 +0000
 90 | URI: /
 91 | Request ID: a819dfc9ec38a94e5a8d4bcea85a0f07
 92 | 
 93 | 
 94 | [root@master0 ~]# curl http://node1.example.com:31111
 95 | Server address: 10.44.0.4:8080
 96 | Server name: dp1-6fc549dc58-fngm2
 97 | Date: 23/Sep/2020:15:25:44 +0000
 98 | URI: /
 99 | Request ID: 8ad1b8407f1b7c2759830b04547b5b49
100 | 
101 | 
102 | [root@master0 ~]# kubectl exec -it pingtest -- /bin/bash
103 | 
104 | 
105 | [root@pingtest /]# curl http://svc-np:9090
106 | Server address: 10.32.0.5:8080
107 | Server name: dp1-6fc549dc58-zgrm5
108 | Date: 23/Sep/2020:15:27:01 +0000
109 | URI: /
110 | Request ID: 2afe05ccb6eb274e4a40f96394a81a39
111 | 
112 | 
113 | [root@pingtest /]# curl http://svc-np.default.svc.cluster.local:9090
114 | Server address: 10.44.0.4:8080
115 | Server name: dp1-6fc549dc58-fngm2
116 | Date: 23/Sep/2020:15:27:12 +0000
117 | URI: /
118 | Request ID: 01d1a7c51d4e9a537fa69320e2075c1e
119 | ```
120 | 
121 | 


--------------------------------------------------------------------------------
/docs/16-install-metallb.md:
--------------------------------------------------------------------------------
 1 | # ติดตั้ง Metallb เมื่อต้องการใช้ Service แบบ LoadBalancer
 2 | หากต้องการใช้ Service แบบ Loadlbalancer จำเป็นต้องติดตั้ง software เพิ่มเติม ผู้เขียนเลือก Metallb เป็นตัวอย่างในเอกสารชุดนี้
 3 | ## แก้ไข Kube-Proxy Configuration และ Restart kube-proxy service [all worker node]
 4 | ```
 5 | [root@node0 kube-proxy]# cat /var/lib/kube-proxy/kube-proxy-config.yaml
 6 | kind: KubeProxyConfiguration
 7 | apiVersion: kubeproxy.config.k8s.io/v1alpha1
 8 | clientConnection:
 9 |   kubeconfig: "/var/lib/kube-proxy/kubeconfig"
10 | mode: "ipvs"
11 | ipvs:
12 |   staticARP: true
13 | clusterCIDR: "10.0.0.0/16"
14 | 
15 | 
16 | systemctl restart kube-proxy
17 | ```
18 | ## ติดตั้ง Metallb และกำหนดค่า ConfigMap สำหรับ Metallb
19 | ```
20 | kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.9.3/manifests/namespace.yaml
21 | kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.9.3/manifests/metallb.yaml
22 | # On first install only
23 | kubectl create secret generic -n metallb-system memberlist --from-literal=secretkey="$(openssl rand -base64 128)"
24 | [root@kube-master ~]# cat metallb-configmap.yml
25 | apiVersion: v1
26 | kind: ConfigMap
27 | metadata:
28 |   namespace: metallb-system
29 |   name: config
30 | data:
31 |   config: |
32 |     address-pools:
33 |     - name: default
34 |       protocol: layer2
35 |       addresses:
36 |       - 192.168.254.200-192.168.254.250
37 | 
38 | kubectl create -f metallb-configmap.yml
39 | ```
40 | ## ทดสอบการทำงานของ Metallb โดยการสร้าง Service แบบ Loadbalancer
41 | ```
42 | [root@kube-master ~]# cat nginx-deployment.yml
43 | apiVersion: apps/v1
44 | kind: Deployment
45 | metadata:
46 |   name: nginx-deployment
47 | spec:
48 |   selector:
49 |     matchLabels:
50 |       app: nginx
51 |   replicas: 2
52 |   template:
53 |     metadata:
54 |       labels:
55 |         app: nginx
56 |     spec:
57 |       containers:
58 |       - name: nginx
59 |         image: nginx:latest
60 |         ports:
61 |         - containerPort: 80
62 | kubectl apply -f nginx-deployment.yml
63 | 
64 | [root@kube-master ~]# cat nginx-service.yml
65 | apiVersion: v1
66 | kind: Service
67 | metadata:
68 |   name: nginx
69 | spec:
70 |   type: LoadBalancer
71 |   selector:
72 |     app: nginx
73 |   ports:
74 |   - port: 80
75 |     name: http
76 | 
77 | kubectl apply -f nginx-service.yml
78 | 
79 | 
80 | [root@kube-master ~]# kubectl get services
81 | NAME    TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
82 | nginx   LoadBalancer   10.109.67.153   192.168.254.200   80:32199/TCP   27m
83 | ```
84 | > จะพบว่า มี Service ขนิดที่เป็น LoadBalancer และมีค่าของ External-IP อยู่
85 | 


--------------------------------------------------------------------------------
/images/README.md:
--------------------------------------------------------------------------------
1 | # Images
2 | 


--------------------------------------------------------------------------------
/images/kube-component.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rdamrong/Kubernetes-The-Hard-Way-CentOS/272ac6ca2c15c8199aa220ece20e7feae3edad47/images/kube-component.png


--------------------------------------------------------------------------------
/images/ss1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rdamrong/Kubernetes-The-Hard-Way-CentOS/272ac6ca2c15c8199aa220ece20e7feae3edad47/images/ss1.png


--------------------------------------------------------------------------------