DEV Community: Anuchit Prasertsang

แก้ปัญหาภาษาไทยใน Git Log | Git Diff

Anuchit Prasertsang — Mon, 06 Oct 2025 15:03:06 +0000

เคยเจอไหม git log แล้วเจอ สระภาษาไทยลอย หรือตัวอักษรเพี้ยน ๆ? ปัญหานี้เกิดจาก Git ใช้โปรแกรมดูไฟล์ชื่อ less เป็นตัวแสดงผล (Pager) แต่เจ้า less ดันไม่รู้ว่าต้องแสดงผลด้วยการเข้ารหัสแบบ UTF-8 ที่รองรับภาษาไทยนั่นเองครับ!

คำสั่งสั้นๆ ที่แก้ไขได้ทันที:

ใช้คำสั่งนี้เพียงครั้งเดียว ตั้งค่าแบบ Global ใช้ได้ทุกโปรเจกต์:

git config --global core.pager "LESSCHARSET=utf-8 less"

คำสั่งนี้ช่วยอะไร? ✨

LESSCHARSET=utf-8: เป็นการบอกกับโปรแกรม less ให้ บังคับ ใช้การเข้ารหัสแบบ UTF-8
ผลที่ได้คือ: less จะสามารถตีความตัวอักษรภาษาไทยได้อย่างถูกต้อง ทำให้สระและวรรณยุกต์กลับไปอยู่ถูกที่ ไม่ลอย อีกต่อไป!

ลองดู git log อีกครั้ง ข้อความภาษาไทยชัดเจนสวยงามทันที!

การใช้ `netcat` เปิดพอร์ตรับข้อความแบบง่ายๆ

Anuchit Prasertsang — Tue, 23 Sep 2025 06:03:38 +0000

เวลาทำงานกับระบบเครือข่าย บางครั้งเราแค่อยากทดสอบการส่งข้อความผ่านพอร์ตแบบเร็วๆ ไม่ต้องเขียนโปรแกรมอะไรให้วุ่นวาย netcat หรือ nc คือเครื่องมือที่เหมาะมากสำหรับงานแบบนี้

เปิดฝั่ง Server

เริ่มจากเปิด Terminal ขึ้นมา แล้วพิมพ์คำสั่งนี้:

nc -l 5555

-l คือรอรับการเชื่อมต่อ (listen)
5555 คือหมายเลขพอร์ตที่เราจะเปิดไว้

หลังจากรันแล้วมันจะค้างไว้ รอให้มีคนมาเชื่อมต่อและส่งข้อความมา

ทดสอบฝั่ง Client

เปิด Terminal อีกหน้าต่าง (หรือจะใช้เครื่องอื่นก็ได้ถ้าอยู่ในวงแลนเดียวกัน) แล้วพิมพ์แบบนี้:

echo "สวัสดีจาก client" | nc 127.0.0.1 5555

หรือถ้าอยากพิมพ์สดๆ ก็ต่อแบบนี้:

nc 127.0.0.1 5555

แล้วพิมพ์อะไรก็ได้ เช่น:

hello server

จากนั้นกด Enter ข้อความจะไปโผล่ที่หน้าจอฝั่ง server

เพิ่มเติม

ถ้าอยากให้รับการเชื่อมต่อได้หลายครั้ง (ไม่หลุดหลัง client ส่งเสร็จ):

nc -lk 5555

-k Forces nc to stay listening for another connection after its current connection is completed.

echo "สวัสดีจาก client" | nc 127.0.0.1 5555

Get Your Go Package on pkg.go.dev: A Simple Guide

Anuchit Prasertsang — Thu, 04 Sep 2025 10:07:23 +0000

Get Your Go Package on pkg.go.dev: A Simple Guide

To get your Go package on pkg.go.dev, you need to publish your code, create a go.mod file, and tag a version.

1. Publish Your Code Publicly

Host your package on a public repository like GitHub, GitLab, or Bitbucket. pkg.go.dev can only access public code.

2. Create a Go Module

Ensure your project's root directory has a go.mod file. If not, run this command, replacing the placeholder with your repository URL:

go mod init github.com/your-username/your-repo-name

3. Tag and Push a Version

pkg.go.dev indexes stable versions, which are marked by a Git tag. The tag must start with a "v".

# Create the tag
git tag v1.0.0

# Push the tag to your remote repository
git push origin v1.0.0

4. Manually Request Indexing

Finally, ask pkg.go.dev to crawl your repository by visiting this URL:

https://pkg.go.dev/github.com/your-username/your-repo-name@v1.0.0

Then click "Request button" on the screen
It may take a few minutes for your page to appear.

Kubernetes YAMLs Demystified: What’s the Difference?

Anuchit Prasertsang — Sat, 30 Aug 2025 04:36:53 +0000

In Kubernetes, a manifest is a YAML (or JSON) file that declares a resource you want to create or manage in the cluster. There are dozens of resource types, but they all fall into a few broad categories.

✅ Common Categories of Kubernetes Manifests

1. Workload Resources (define what runs)

Kind	Purpose
`Pod`	The smallest deployable unit
`Deployment`	Declarative updates for Pods
`ReplicaSet`	Maintains a stable set of Pods
`StatefulSet`	Pods with stable identity/storage
`DaemonSet`	One Pod per node
`Job`	One-off task
`CronJob`	Scheduled Jobs

2. Service & Networking (define how things connect)

Kind	Purpose
`Service`	Stable access to Pods
`Ingress`	HTTP routing to Services
`IngressClass`	Ingress controller config
`EndpointSlice`	Tracks Service endpoints
`NetworkPolicy`	Controls traffic rules

3. Configuration & Secrets (define app config)

Kind	Purpose
`ConfigMap`	Key-value config
`Secret`	Encrypted key-value config
`ServiceAccount`	Identity for Pods
`ResourceQuota`	Limit resource usage per namespace
`LimitRange`	Default/limit CPU/mem per Pod

4. Storage Resources

Kind	Purpose
`PersistentVolume` (PV)	Cluster-managed storage unit
`PersistentVolumeClaim` (PVC)	Request for a PV
`StorageClass`	Defines dynamic volume provisioning
`VolumeAttachment`	CSI plugin volume tracking

5. Cluster-Level Resources

Kind	Purpose
`Namespace`	Isolate resources into groups
`Node`	Represents a worker machine
`Role` / `ClusterRole`	Permissions (RBAC)
`RoleBinding` / `ClusterRoleBinding`	RBAC assignment
`CustomResourceDefinition (CRD)`	Add new resource types

6. Custom Resources (via CRDs)

These are user-defined kinds created via CustomResourceDefinition
Examples:
- KafkaTopic (via Strimzi)
- CertManager resources
- ArgoCD CRDs
- PrometheusRule, etc.

🧾 Summary Table of Core Kubernetes Manifest Kinds

Category	Example Kinds
Workloads	Deployment, Pod, Job, CronJob
Networking	Service, Ingress, NetworkPolicy
Configuration	ConfigMap, Secret, ServiceAccount
Storage	PV, PVC, StorageClass
Cluster Management	Node, Namespace, Role, CRD
Custom Resources	Anything from a CRD

What is the Chrome `--app` Flag?

Anuchit Prasertsang — Mon, 25 Aug 2025 05:47:58 +0000

The --app flag in Google Chrome lets you open any website in a clean, minimal window—no address bar, tabs, or browser buttons. It’s a great way to run web apps as if they were standalone desktop applications.

Example

/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --app="https://www.example.com"

This command launches example.com in its own simplified window.

Why It’s Useful

Gets rid of the usual browser interface
Makes web apps feel more like native apps
Keeps things tidy by opening the site in a separate window

Keep in mind: This is a Chrome-specific feature and doesn’t work the same way in browsers like Firefox.

Kubernetes คืออะไร? แบบ Dev เห็นภาพ

Anuchit Prasertsang — Sun, 08 Dec 2024 03:04:28 +0000

ลองนึกถึงชีวิตจริงของเรา เมื่อเราต้องการส่งของขวัญให้ใครสักคน สิ่งที่เราต้องมีคือระบบไปรษณีย์ ไปรษณีย์จะบอกเราว่า “เราสามารถส่งของให้คุณได้ แต่ว่าคุณต้องเตรียมบรรจุภัณฑ์ที่ได้มาตรฐาน” นั่นหมายความว่า ถ้าคุณจะส่งทุเรียน ก็ต้องห่อให้เรียบร้อย ไม่ใช่แค่เอาทุเรียนลูกใหญ่ไปส่งเลย ต้องมีการเตรียมพร้อมในการจัดส่งเพื่อให้มันถึงปลายทางได้อย่างปลอดภัย

หรือถ้าคุณจะส่งหนังสือ ก็ต้องใส่ซองจดหมายให้เรียบร้อย ในกรณีนี้ก็จะมีค่าใช้จ่ายในการจัดส่ง ค่าใช้จ่ายนี้จะขึ้นอยู่กับระยะทางและน้ำหนักของพัสดุ ซึ่งเราสามารถจ่ายเป็นสแตมป์ได้ตามที่เห็นสมควร

แต่สิ่งที่สำคัญคือ ไม่ว่าจะใส่อะไรลงไปในพัสดุ ขอแค่บรรจุภัณฑ์มันสามารถรองรับได้ตามมาตรฐาน ระบบไปรษณีย์ก็จะทำหน้าที่ส่งถึงปลายทางให้ได้

ทีนี้ ลองนำหลักการนี้มาคิดในแง่ของ Kubernetes ถ้าเราต้องการให้ Kubernetes มีประสิทธิภาพเหมือนระบบขนส่งไปรษณีย์ เราต้องอธิบายว่าเราจะส่งอะไร ไปที่ไหน (ที่อยู่ปลายทาง) และมันจะไปรันที่ไหน? ใครจะรันมัน? เรารอได้นานแค่ไหน? การตอบคำถามเหล่านี้เหมือนกับการที่เราเตรียมพัสดุให้พร้อมก่อนส่งให้ไปรษณีย์

Kubernetes ทำงานเหมือนกับระบบไปรษณีย์ที่ซ่อนความซับซ้อนต่างๆ ไว้เบื้องหลัง เราไม่จำเป็นต้องรู้ว่าในกระบวนการขนส่งเกิดอะไรขึ้นบ้าง เพียงแค่เราติดสแตมป์ ใส่ที่อยู่ปลายทาง แล้วระบบไปรษณีย์จะรับประกันว่าในที่สุดพัสดุของเราจะถึงมือผู้รับภายในระยะเวลาที่กำหนด แม้ว่าเครื่องบินอาจจะพังหรือรถบรรทุกอาจจะเสีย ระบบไปรษณีย์ก็ไม่โทรหาเราเพื่อแจ้งเหตุการณ์เหล่านั้น มันเป็นสิ่งที่เราไม่จำเป็นต้องรู้และไม่ต้องกังวล เพราะเขาได้สัญญากับเราว่าจะจัดส่งพัสดุถึงที่ให้ได้

ในลักษณะเดียวกัน Kubernetes ก็ใช้หลักการที่เรียกว่า Promise Theory ระบบของ Kubernetes จะมีโหนดหรือเครื่องในคลัสเตอร์จำนวนมาก ซึ่งบางเครื่องอาจจะพังไปบ้าง แต่ Kubernetes รับประกันว่าแอปพลิเคชันของเราจะต้องรันอยู่เสมอ ระบบจะทำให้เรามั่นใจว่าแอปจะทำงานต่อไปไม่ว่าคลัสเตอร์จะเกิดปัญหาหรือไม่

เปรียบเทียบกับไปรษณีย์ Kubernetes ซ่อนรายละเอียดทางเทคนิคทั้งหมดไว้เบื้องหลัง และอนุญาตให้นักพัฒนาแค่ใส่แอปพลิเคชันลงไปในกล่อง พิมพ์ที่อยู่ปลายทาง แล้วจ่ายสแตมป์ (หรือบอกว่าจะให้ Kubernetes ดูแลการรันแอป) ทุกอย่างที่เหลือ Kubernetes จะจัดการให้

https://youtu.be/BE77h7dmoQU?t=472

ปัญหาของการจัดการเวลาในระบบกระจาย: Lamport Clock

Anuchit Prasertsang — Tue, 26 Nov 2024 08:49:26 +0000

ในระบบกระจาย (Distributed Systems) ปัญหาหนึ่งที่มักพบคือการประสานเวลาระหว่างเครื่องต่างๆ ที่ไม่มีการเชื่อมต่อกันโดยตรง ซึ่งเป็นเรื่องยากที่ทุกเครื่องในระบบจะเห็นเวลาเดียวกัน หรือสามารถจัดลำดับเหตุการณ์ที่เกิดขึ้นในแต่ละเครื่องได้อย่างถูกต้อง

ปัญหาคืออะไร?

ในระบบกระจาย เมื่อเครื่องหลายเครื่องทำงานพร้อมกัน มักจะมีการดำเนินการต่างๆ เช่น การส่งข้อความจากเครื่องหนึ่งไปยังอีกเครื่องหนึ่ง ซึ่งการจะทำให้เครื่องแต่ละเครื่องสามารถเข้าใจลำดับเหตุการณ์เหล่านั้นได้เป็นสิ่งที่ท้าทาย เพราะแต่ละเครื่องอาจจะมีการตั้งเวลา (Clock) ที่ไม่ตรงกันหรือแตกต่างกัน และอาจจะไม่ได้อยู่ในสภาพแวดล้อมที่สามารถซิงโครไนซ์เวลาได้ตลอดเวลา

ยกตัวอย่างเช่น หากเครื่องหนึ่งส่งข้อความไปยังเครื่องอื่น เราจะรู้ได้อย่างไรว่าเหตุการณ์นี้เกิดขึ้นก่อนหรือหลังจากเหตุการณ์อื่นในเครื่องที่ต่างกัน?

Solving the Problem: Lamport Clock

Lamport Clock เป็นกลไกที่ถูกพัฒนาขึ้นมาเพื่อแก้ไขปัญหานี้ โดยไม่จำเป็นต้องมีการซิงโครไนซ์เวลาในระบบทั้งหมด แต่ให้ทุกเครื่องสามารถรักษาลำดับเหตุการณ์ได้ด้วยการใช้ตัวนับเหตุการณ์ (logical clock) ที่ถูกปรับปรุงเมื่อมีการส่งหรือรับข้อความระหว่างเครื่องต่างๆ

หลักการของ Lamport Clock:

ทุกเครื่องในระบบจะมีการตั้งตัวนับเหตุการณ์ (logical clock) ของตนเอง
เมื่อเครื่องทำการส่งข้อความไปยังเครื่องอื่น ตัวนับของเครื่องต้นทางจะเพิ่มขึ้นก่อนส่งข้อความ
เมื่อเครื่องรับข้อความจากเครื่องต้นทาง ตัวนับของเครื่องรับจะถูกปรับขึ้นให้สูงกว่า (max) ระหว่างตัวนับของเครื่องตัวเองและตัวนับที่ส่งมาจากเครื่องต้นทาง
ด้วยวิธีนี้ ทุกเครื่องจะสามารถติดตามลำดับเหตุการณ์ในระบบกระจายได้โดยไม่จำเป็นต้องใช้เวลาจริง (real clock) ที่ซิงโครไนซ์กัน

ข้อดีและข้อจำกัดของ Lamport Clock

ข้อดี: ระบบสามารถทำงานได้แม้เครื่องต่างๆ จะไม่ซิงโครไนซ์เวลา เนื่องจากใช้ตัวนับเหตุการณ์ในการจัดการลำดับเหตุการณ์
ข้อจำกัด: Lamport Clock สามารถช่วยได้เพียงแค่การจัดลำดับเหตุการณ์เท่านั้น และไม่สามารถบอกได้ว่าเหตุการณ์ใดเกิดขึ้นก่อนหรือหลังอย่างแน่ชัด เนื่องจากมันไม่ใช่การจับเวลาในเชิงปริมาณ (absolute time)

สรุป

Lamport Clock เป็นแนวทางที่มีประโยชน์ในการจัดการเวลาในระบบกระจายโดยไม่ต้องพึ่งพาการซิงโครไนซ์เวลาจริงระหว่างเครื่อง แต่ยังคงสามารถรักษาลำดับเหตุการณ์ได้ในระดับที่เพียงพอสำหรับการประสานงานในระบบที่กระจายทั่วกัน

https://martinfowler.com/articles/patterns-of-distributed-systems/lamport-clock.html

คำสั่ง tr สำหรับแปลงหรือลบตัวอักษร

Anuchit Prasertsang — Fri, 08 Nov 2024 11:24:17 +0000

โครงสร้างพื้นฐาน

tr [OPTIONS]  STRING1 [STRING2]

STRING1: ชุดตัวอักษรที่ต้องการแปลงหรือลบ
[STRING2]: ตัวอักษรที่ใช้แทน (optional)

แทนที่ตัวอักษร : แทนด้วยบรรทัดใหม่ \n

echo "path1:path2:path3" | tr ':' '\n'

ผลลัพธ์:

path1
path2
path3

ลบตัวอักษร o จากข้อความ

echo "hello world" | tr -d 'o'

ผลลัพธ์: hell wrld

ลดตัวอักษรที่ซ้ำ ลดช่องว่างซ้ำให้เหลือช่องเดียว

echo "hello     world" | tr -s ' '

ผลลัพธ์: hello world

ลองไปใช้กันดู

อัพเดทเวอร์ชั่น Container runtime Colima

Anuchit Prasertsang — Fri, 01 Nov 2024 15:04:05 +0000

วิธีการอัพเดท container runtime สำหรับ Colima ใช้
คำสั่ง
colima update

ตรวจสอบเวอร์ชั่นปัจจุบันได้ด้วย colima version

$ colima version

colima version 0.7.6
git commit: 3ab92f54210503770223a8c9bb61662725e23004

runtime: docker
arch: aarch64
client: v27.2.0
server: v24.0.9

ทำการรัน colima update

$ colima version

colima version 0.7.6
git commit: 3ab92f54210503770223a8c9bb61662725e23004

runtime: docker
arch: aarch64
client: v27.2.0
server: v27.1.1

สังเกตว่า server version จะปรับจาก v24.0.9 ไปเป็น v27.1.1 เรียบร้อย

การใช้ GitLab สำหรับแชร์ Configuration ให้คนในทีม โดยไม่ใช้แชท

Anuchit Prasertsang — Thu, 31 Oct 2024 14:54:11 +0000

ปัญหา

เมื่อเราทำงานในทีมที่มีคนหลายคน การแชร์ configuration หรือรหัสต่างๆของโปรเจคสำหรับ ระหว่างนักพัฒนานั้น
เป็นหนึ่งปัญหาที่อยากลำบาก ถ้าไม่มี Vault ส่วนใหญ่ก็จะส่งกันผ่านทางแชท ซึ่งไม่ค่อยปลอดภัยเท่าไหร่

ใช้ GitLab Secure files ในการแชร์ Configuration

สร้างไฟล์ที่จะแชร์ นำไปไว้ที่ GitLab Repository

สร้างไฟล์ที่จะเก็บ configuration ขึ้นมาในโปรเจคของเรา กรณีนี้เราจะสร้างไฟล์ชื่อ env.backend ขึ้นมา ซึ่งเป็น key-value ของ environment ของ backend ตัวอย่างเช่น

ENV_BACKEND=production
DATABASE_URL=postgres://user:password@host:port/dbname

ไปที่ GitLab โปรเจคของเรา แล้วไปที่ Settings > CI/CD > Secure files แล้วอัพโหลดไฟล์ env.backend ขึ้นไป

ใช้ Secure Files API ในการดึงไฟล์จาก GitLab ลงมาที่เครื่องของเรา

สร้าง Personal Access Token ใน GitLab โดยไปที่ User Settings > Access Tokens แล้วสร้าง Token ขึ้นมา
ใช้ Token ที่สร้างขึ้นมาในการดึงไฟล์จาก GitLab โดยใช้ Secure Files API โดยใช้คำสั่ง

    curl --header "PRIVATE-TOKEN: <GITLAB_ACCESS_TOKEN>" \
        "https://gitlab.com/api/v4/projects/<PROJECT_ID>/secure_files/<FILE_ID>/download" \
        --output <OUTPUT_FILE_NAME>

โดยที่

<GITLAB_ACCESS_TOKEN> คือ Personal Access Token ที่สร้างขึ้นมา
<PROJECT_ID> คือ ID ของโปรเจคที่เรา (อยู่ใกล้ปุ่ม Fork ของโปรเจค หรือไปที่ Settings > General แล้วดูที่ Project ID)
<FILE_ID> คือ ID ของไฟล์ที่เราอยากดาวน์โหลด เราสามารถใช้ Secure Files API ในการดูรายละเอียดของไฟล์ทั้งหมดได้
<OUTPUT_FILE_NAME> คือ ชื่อไฟล์ที่เราอยากจะบันทึกไฟล์ที่ดาวน์โหลดลงมาในเครื่องของเรา

ดูรายละเอียดของ Secure Files ทั้งหมด

curl --header "PRIVATE-TOKEN: <GITLAB_ACCESS_TOKEN>" \
    "https://gitlab.com/api/v4/projects/<PROJECT_ID>/secure_files"

ตัวอย่างผลลัพธ์

[
        {
                "id": 2233783, // FILE_ID
                "filename": "env.backend", // FILE_NAME
                "filesize": 30,
                "filetype": "text/plain",
                ... // รายละเอียดอื่นๆ
        }
]

เพียงเท่านี้เราก็สามารถแชร์ configuration ระหว่างนักพัฒนาได้โดยไม่ต้องส่งผ่านทางแชทอีกต่อไป

อ้างอิง

Secure File API

สร้าง Kubernetes Secret manifest file สำหรับ Private Image Registry

Anuchit Prasertsang — Thu, 03 Oct 2024 08:23:38 +0000

ความเดิมตอนที่แล้ว

เราสามารถสร้าง

เราสามารถไฟล์ file secrete manifest เอาไว้ใช้งานได้ดังนี้

gitlab-registry-secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: regcred
  namespace: default  # Change this if you want to use a different namespace
type: kubernetes.io/dockerconfigjson
data:
  .dockerconfigjson: <base64-encoded-docker-config>

<base64-encoded-docker-config> นำมาจากการ encode ไฟล์ config.json

โดยใช้คำสั่ง cat config.json | base64

ลักษณะของไฟล์ docker/config.json

{
  "auths": {
    "<REGISTRY_UR>": {
      "username": "<REGISTRY_USERNAME>",
      "password": "<REGISTRY_PASSWORD>",
      "email": "<REGISTRY_EMAIL>"
    }
  }
}

ตัวอย่างเช่น

{
  "auths": {
    "https://registry.gitlab.com": {
      "username": "mygitlab",
      "password": "glpat-xk......E5",
      "email": "hello@gmail.com"
    }
  }
}

จากนั้นทำการ
kubectl apply -f gitlab-registry-secret.yaml

ก็เป็นอันเรียบร้อย

ดึง Images จาก Private Registry - Kubernetes

Anuchit Prasertsang — Thu, 03 Oct 2024 04:44:54 +0000

ดึง Image จาก Private Registry สำหรับ Kubernetes

สร้าง docker-registry secret ใน Kubernetes

kubectl create secret docker-registry SECRET_NAME \
  --docker-server=REGISTRY_URL \
  --docker-username=REGISTRY_USERNAME \
  --docker-password=REGISTRY_PASSWORD \
  --docker-email=REGISTRY_EMAIL

SECRET_NAME ชื่อของ secret ตั้งเป็นอะไรก็ได้
REGISTRY_URL แทนที่ด้วย registry server เช่น https://registry.gitlab.com หรือ https://ghcr.io หรือ https://index.docker.io/v1/
REGISTRY_USERNAME แทนที่ด้วย username ที่คุณใช้กับ Registry นั้น
REGISTRY_PASSWORD แทนที่ด้วยรหัสผ่าน ถ้าเป็น GitLab, GitHub ให้ใช้ Access Token
REGISTRY_EMAILแทนที่ด้วยอีเมล์ของคุณที่ใช้กับ Registry นั้น

ตัวอย่าง GitLab Registry

kubectl create secret docker-registry gitlab-registry-secret \
  --docker-server=https://registry.gitlab.com \
  --docker-username=mygitlab \
  --docker-password=glpat-xk......E5 \
  --docker-email=hello@gmail.com

เพิ่ม imagePullSecrets ใน ไฟล์ deployment manifest หรือ ใน pod

spec:
  imagePullSecrets:
    - name: gitlab-registry-secret

ตัวอย่างเช่น

apiVersion: v1
kind: Pod
metadata:
  name: api-service
spec:
  hostNetwork: true
  containers:
  - name: api-service
    image: registry.gitlab.com/<mygitlab>/<repo>/<images>:v1.0.0

  imagePullSecrets: 
  - name: gitlab-registry-secret

จากนั้นก็สั่ง apply ได้เลย kubectl apply -f pod.yaml

หมายเหตุ: ถ้าจะใช้ image pull secrets กับ Pod (หรือ Deployment หรืออื่น ๆ ที่มี pod template) ต้องตรวจสอบให้แน่ใจว่า Secret ที่เราต้องการมีอยู่ใน namespace ที่ถูกต้อง ซึ่ง namespace นั้นต้องเป็น namespace เดียวกับที่เรากำหนด Pod ไว้ด้วยนะ

Reference:

https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/