DEV Community: Pargorn Ruasijan

วิธีใช้ OWASP ZAP ทดสอบความปลอดภัยของเว็บแอปพลิเคชัน โดยใช้ OWASP Juice Shop

Pargorn Ruasijan — Fri, 13 Jun 2025 14:34:00 +0000

การทดสอบช่องโหว่ของเว็บแอปพลิเคชันเป็นสิ่งที่จำเป็นสำหรับนักพัฒนาและผู้ดูแลระบบ OWASP ZAP เป็นหนึ่งในเครื่องมือยอดนิยมที่ช่วยให้เราสามารถตรวจสอบความปลอดภัยของเว็บแอปได้อย่างมีประสิทธิภาพ

ในบทความนี้ เราจะพาไปรู้จักกับ OWASP ZAP และวิธีใช้งานร่วมกับ Juice Shop เพื่อค้นหาและวิเคราะห์ช่องโหว่ของเว็บแอป

OWASP ZAP คืออะไร

OWASP ZAP (Zed Attack Proxy) เป็นเครื่องมือ Open Source ที่ช่วยทดสอบความปลอดภัยของเว็บแอปพลิเคชันโดยการสแกนหาช่องโหว่ เช่น SQL Injection, Cross-Site Scripting (XSS), Security Misconfiguration และอื่น ๆ

ZAP มีฟีเจอร์ที่หลากหลาย เช่น การสแกนอัตโนมัติ การตรวจสอบความปลอดภัยแบบ Manual การสร้างรายงาน และการสนับสนุนการทำงานร่วมกับเครื่องมืออื่น ๆ ZAP เป็นเครื่องมือที่เหมาะสำหรับนักพัฒนาซอฟต์แวร์ นักทดสอบความปลอดภัย และผู้ที่สนใจในด้าน Cybersecurity

OWASP Juice Shop คืออะไร

OWASP Juice Shop เป็นเว็บแอปพลิเคชันที่สร้างขึ้นเพื่อใช้เป็นตัวอย่างในการทดสอบช่องโหว่ด้านความปลอดภัย มันเต็มไปด้วยช่องโหว่ยอดนิยมตาม OWASP Top 10 ซึ่งเหมาะสำหรับใช้เรียนรู้และฝึกฝนการทดสอบด้าน Security
Juice Shop มีฟีเจอร์ที่หลากหลาย เช่น การจัดการบัญชีผู้ใช้ การชำระเงินออนไลน์ และการจัดการสินค้า ซึ่งทำให้มันเป็นตัวอย่างที่ดีในการทดสอบความปลอดภัยของเว็บแอปพลิเคชัน

ติดตั้งและรัน OWASP Juice Shop บน Local

Juice Shop รองรับหลายวิธีในการรัน เช่น Docker, Node.js, Heroku, และ AWS
ในที่นี้เราจะใช้ Docker เพื่อรัน Juice Shop บน Local

แต่วันนี้เราจะใช้ Docker ในการติดตั้ง Juice Shop เพราะมันง่ายและรวดเร็ว

ติดตั้ง Docker บนเครื่อง ดาวน์โหลดที่นี่
เปิด Terminal และรันคำสั่ง

docker run -p 8888:3000 bkimminich/juice-shop

รอจนกระทั่ง Juice Shop รันเสร็จ จากนั้นเปิดเว็บเบราว์เซอร์และไปที่ http://localhost:8888

ติดตั้งและตั้งค่า OWASP ZAP

ติดตั้ง OWASP ZAP

ดาวน์โหลด OWASP ZAP จาก เว็บไซต์ทางการ
ติดตั้งตามขั้นตอนของระบบปฏิบัติการที่คุณใช้งาน
เปิด OWASP ZAP

ตั้งค่า Proxy ใน OWASP ZAP

เปิด ZAP แล้วไปที่ Tools → Options → Network → Local Server/Proxies
ตั้งค่า Address เป็น localhost และ Port เป็น 8080
กด OK เพื่อบันทึกการตั้งค่า

การตั้งค่า Proxy จะช่วยให้ ZAP สามารถดักจับและวิเคราะห์การเชื่อมต่อระหว่างเว็บเบราว์เซอร์และ Juice Shop ได้ เรียกง่าย ๆ ว่า ทุก Request ที่ส่งจากเบราว์เซอร์จะถูกส่งไปยัง ZAP

ใช้ OWASP ZAP สแกน OWASP Juice Shop

สแกนอัตโนมัติ (Automated Scan)

เปิด OWASP ZAP → ไปที่แท็บ Quick Start
เลือก Automated Scan

ใส่ URL ของ Juice Shop (http://localhost:8888) ในช่อง URL to attack
กด Attack เพื่อเริ่มการสแกน

รอจนกระทั่งการสแกนเสร็จสิ้น
เมื่อการสแกนเสร็จสิ้น คุณจะเห็นรายงานช่องโหว่ที่พบในแท็บ Alerts
วิเคราะห์และแก้ไขปัญหาที่พบ
ไปที่แท็บ Alerts คุณจะเห็นรายการช่องโหว่ เช่น

ตารางแสดงตัวอย่างการสแกนช่องโหว่

ระดับความเสี่ยง	ประเภทช่องโหว่	วิธีแก้ไข
🔴 High	SQL Injection	ใช้คำสั่ง SQL ที่ปลอดภัย (Prepared Statements) หรือใช้ ORM เพื่อลดความเสี่ยง
🟡 Medium	Content Security Policy (CSP) Header Not Set	เพิ่ม CSP Header เพื่อป้องกันการโจมตีแบบ XSS และการโหลดเนื้อหาจากแหล่งที่ไม่ปลอดภัย
🟢 Low	X-Content-Type-Options Header Missing	ตั้งค่า X-Content-Type-Options: nosniff ใน Header เพื่อป้องกันการแอบเปลี่ยนประเภทไฟล์

คลิกที่ช่องโหว่เพื่อดูรายละเอียดเพิ่มเติม เช่น คำอธิบาย วิธีการโจมตี และวิธีการแก้ไข
คุณสามารถคลิกที่ Request และ Response เพื่อดูรายละเอียดของ Request และ Response ที่ถูกส่งไปยัง Juice Shop
คุณสามารถใช้ข้อมูลเหล่านี้ในการวิเคราะห์และปรับปรุงความปลอดภัยของเว็บแอปพลิเคชัน
นอกจากนี้ ZAP ยังมีฟีเจอร์การสร้างรายงานที่ช่วยให้คุณสามารถบันทึกผลการสแกนได้
ไปที่ Report → Generate Report
เลือกรูปแบบรายงานที่ต้องการ เช่น HTML, XML, Markdown
กด Generate เพื่อสร้างรายงาน
รายงานจะถูกบันทึกในโฟลเดอร์ที่คุณเลือก

การ Deploy Flask API ด้วย Kubernetes

Pargorn Ruasijan — Fri, 13 Jun 2025 14:29:44 +0000

Kubernetes เป็นเครื่องมือสำหรับการจัดการแอปพลิเคชันที่ใช้ container อย่าง Docker ซึ่งช่วยให้เราสามารถ deploy และ scale แอปพลิเคชันได้ง่าย
ในบทความนี้เราจะมา deploy Flask API ด้วย Kubernetes โดยจะแสดงขั้นตอนตั้งแต่การเตรียมแอปพลิเคชันไปจนถึงการ deploy ลงใน Kubernetes cluster

ขั้นตอนที่ 1 เตรียม Flask API

เริ่มต้นด้วยการสร้าง Flask API ง่าย ๆ สำหรับการทดสอบ

1. สร้างโฟลเดอร์ใหม่สำหรับโปรเจค Flask

mkdir flask-api
cd flask-api

2. สร้างไฟล์ app.py สำหรับ Flask API

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, Kubernetes!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

3. สร้างไฟล์ requirements.txt

Flask==3.1.0

ขั้นตอนที่ 2 สร้าง Docker Image สำหรับ Flask API

1. สร้างไฟล์ Dockerfile ในโฟลเดอร์โปรเจค

# ใช้ base image จาก Python
FROM python:3.9-slim

# กำหนด directory ภายใน container
WORKDIR /app

# คัดลอกไฟล์ requirements.txt และติดตั้ง dependencies
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt

# คัดลอกโค้ดไปยัง /app/ ใน container
COPY . /app/

# เปิด port ที่จะใช้งาน
EXPOSE 5000

# รัน Flask API
CMD ["python", "app.py"]

2. สร้าง Docker image

docker build -t flask-api .

3. ทดสอบการทำงานของ Flask API ใน Docker

docker run -p 5000:5000 flask-api

เปิด browser และไปที่ http://localhost:5000 จะเห็นข้อความ “Hello, Kubernetes!”

ขั้นตอนที่ 3 เตรียม Kubernetes

สร้างไฟล์สำหรับการ deploy แอปพลิเคชันใน Kubernetes

1. สร้างไฟล์ flask-api-deployment.yaml สำหรับ Deployment และ Service

apiVersion: apps/v1
kind: Deployment
metadata:
  name: flask-api
spec:
  replicas: 3  # จำนวน replicas หรือ pod ที่ต้องการ
  selector:
    matchLabels:
      app: flask-api
  template:
    metadata:
      labels:
        app: flask-api
    spec:
      containers:
      - name: flask-api
        image: <username>/flask-api:latest  # Docker image ที่เราสร้างขึ้น
        ports:
        - containerPort: 5000

---
apiVersion: v1
kind: Service
metadata:
  name: flask-api-service
spec:
  selector:
    app: flask-api
  ports:
    - protocol: TCP
      port: 80
      targetPort: 5000 # Port ของ container
  type: LoadBalancer

Deployment กำหนดจำนวน replicas ของ pod (ที่นี่ตั้งไว้ 3 replicas) และ image ที่จะใช้ในการ deploy
Service กำหนด service ที่เชื่อมต่อกับ pod ซึ่งจะเปิด port 80 และเชื่อมต่อกับ port 5000 ของ container

ขั้นตอนที่ 4 Deploy Flask API ไปยัง Kubernetes

1. อัปโหลด Docker image ไปยัง Docker registry (เช่น Docker Hub หรือ GCR)

GCR คือ Google Container Registry ที่ใช้เก็บ Docker image บน Google Cloud Platform แบบ Private Registry

docker tag flask-api:latest <username>/flask-api:latest
docker push <username>/flask-api:latest

2. ใช้ kubectl เพื่อ deploy แอปพลิเคชันไปยัง Kubernetes cluster

kubectl apply -f flask-api-deployment.yaml

3. ตรวจสอบการทำงานของ Deployment

kubectl get deployments

ถ้าคุณเห็น replicas ที่ต้องการและ replicas ที่กำลังทำงาน แสดงว่า Deployment ทำงานถูกต้อง (อย่างน้อยต้องมี Ready 1 จาก 3) แต่ควรมี Ready 3 จาก 3 ถ้าไม่มีปัญหาใด ๆ

4. ตรวจสอบ Pod

kubectl get pods

ถ้า Pod ทั้งหมดมีสถานะ Running แสดงว่า Pod ทำงานถูกต้อง

5. ตรวจสอบ Service

kubectl get services

ถ้าใช้ LoadBalancer service ต้องใช้ EXTERNAL-IP เพื่อเข้าถึง Flask API ในที่นี้คือ localhost

ขั้นตอนที่ 5 ทดสอบการทำงานของ Flask API บน Kubernetes

หากคุณใช้ LoadBalancer service เปิด browser และไปที่ IP ที่ได้จาก kubectl get services และ port 80
คุณควรเห็นข้อความ “Hello, Kubernetes!”

ขั้นตอนที่ 6 การอัปเดต

1. หากต้องการอัปเดตแอปพลิเคชัน เพียงแค่สร้าง Docker image ใหม่และอัปโหลดไปยัง Docker registry

docker build -t flask-api:latest .
docker tag flask-api:latest <username>/flask-api:latest
docker push <username>/flask-api:latest

2. ทำการ update deployment บน Kubernetes

kubectl set image deployment/flask-api flask-api=<username>/flask-api:latest

3. ตรวจสอบการอัปเดต

kubectl get pods

สรุป

การ deploy Flask API ด้วย Kubernetes เป็นวิธีที่ดีในการจัดการแอปพลิเคชันที่สามารถ scale ได้
ถ้าต้องการความสะดวกในการจัดการ Kubernetes cluster การใช้ Rancher จะทำให้คุณสามารถ deploy ได้เร็วขึ้นและง่ายมากขึ้น Rancher มี UI ที่ใช้งานง่ายและช่วยให้คุณสามารถจัดการ Kubernetes cluster ได้ง่ายขึ้น

ถ้ากำลังมองหาวิธีการ deploy Flask API ที่สะดวกและรวดเร็ว การใช้ Rancher ร่วมกับ Kubernetes น่าจะเป็นทางเลือกที่ดีครับผมมม ลองดูกันนะครับผมมม

Python Web Framework ความแตกต่างระหว่าง Flask และ Django

Pargorn Ruasijan — Fri, 13 Jun 2025 14:23:00 +0000

ถ้าคุณอยากใช้ Python ที่อยากสร้างเว็บแอปพลิเคชันสักตัว แต่ยังไม่แน่ใจว่าจะเลือกใช้ Flask หรือ Django ดี ลองมาดูข้อแตกต่างระหว่างสองตัวนี้กันดีกว่า! ทั้งสองเป็น Framework ที่ยอดนิยมในวงการ Python แต่ก็มีลักษณะการใช้งานที่ต่างกัน ถ้าพร้อมแล้วก็มาเริ่มกันเลย!

Flask – ตัวเล็กๆ แต่แจ่ม

Flask เป็น Microframework ที่เน้นความเรียบง่าย และให้ความยืดหยุ่นสูง คุณสามารถเริ่มต้นโปรเจกต์ได้ง่ายๆ โดยไม่ต้องตั้งค่ามากมาย เหมาะกับคนที่ชอบควบคุมทุกอย่างเอง

ข้อดีของ Flask

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

ข้อเสียของ Flask

ต้องเพิ่มฟีเจอร์เอง ถ้าคุณต้องการฟีเจอร์บางอย่าง เช่น ระบบ Admin หรือการจัดการแบบ Form Flask จะต้องใช้ Extension เสริม
อาจไม่เหมาะกับโปรเจกต์ใหญ่ ถ้าคุณกำลังทำโปรเจกต์ขนาดใหญ่ที่ต้องการฟีเจอร์ครบถ้วน Flask อาจจะไม่เหมาะเท่าไหร่

Django – แพ็คเกจครบจบในตัว

Django คืออะไร?

Django เป็น Full-stack Framework ที่มาพร้อมกับฟีเจอร์ครบครัน ไม่ว่าจะเป็นระบบจัดการฐานข้อมูล, ระบบล็อกอิน, หรือเครื่องมือสำหรับจัดการ URL ก็มีมาให้ในตัว

ข้อดีของ Django

ครบทุกฟีเจอร์ Django มีทุกอย่างที่คุณต้องการในตัว เช่น ระบบ Admin, Authentication, ORM (จัดการฐานข้อมูล) และระบบ Routing
ปลอดภัยสูง Django มีระบบความปลอดภัยในตัว ช่วยป้องกันการโจมตีต่างๆ อย่าง SQL Injection หรือ Cross-Site Scripting
เหมาะกับโปรเจกต์ใหญ่ Django เหมาะกับโปรเจกต์ที่ต้องการความเสถียรและฟีเจอร์เยอะๆ เช่น เว็บแอปพลิเคชันขนาดใหญ่ หรือ e-commerce

ข้อเสียของ Django

เรียนรู้ยากกว่า ถ้าคุณเพิ่งเริ่มต้น Django อาจจะดูซับซ้อนนิดหน่อยเพราะมันมาพร้อมกับฟีเจอร์มากมาย
มีโครงสร้างที่ตายตัว คุณอาจจะรู้สึกว่า Django ไม่ยืดหยุ่นเท่า Flask เพราะมันมีโครงสร้างที่ค่อนข้างตายตัว

Flask vs Django – เปรียบเทียบกันหน่อย

Feature	Flask	Django
การเรียนรู้	ง่ายและเร็ว	มีความซับซ้อนแต่เข้าใจได้เร็วขึ้นเมื่อใช้งาน
ขนาดของโปรเจกต์	เหมาะกับโปรเจกต์เล็กถึงกลาง	เหมาะกับโปรเจกต์ใหญ่
ฟีเจอร์ในตัว	ต้องใช้ extensions	ฟีเจอร์ครบถ้วนในตัว
ความยืดหยุ่น	สูงมาก	ค่อนข้างตายตัว แต่ยังปรับแต่งได้
ความปลอดภัย	ต้องเพิ่มฟีเจอร์เอง	มีระบบความปลอดภัยในตัว

สรุป

ถ้าคุณอยากเริ่มต้นโปรเจกต์ง่ายๆ หรืออยากสร้างเว็บแอปพลิเคชันเล็กๆ แบบไม่ต้องการตั้งค่าเยอะๆ Flask เป็นตัวเลือกที่ดี
แต่ถ้าคุณกำลังทำโปรเจกต์ใหญ่ที่ต้องการฟีเจอร์ครบครันและความเสถียร Django น่าจะเหมาะกว่า

การเลือกใช้ Flask หรือ Django ขึ้นอยู่กับความต้องการและขนาดของโปรเจกต์ข ถ้าคุณเพิ่งเริ่มพัฒนาเว็บ แนะนำให้เริ่มจาก Flask

การจัดการสิทธิ์ไฟล์ (File Permission) ใน Linux

Pargorn Ruasijan — Fri, 13 Jun 2025 14:07:00 +0000

Linux มีระบบจัดการสิทธิ์ (Permission) ที่มีประสิทธิภาพ เพื่อควบคุมการเข้าถึงไฟล์และโฟลเดอร์ ระบบนี้ช่วยป้องกันการเข้าถึงโดยไม่ได้รับอนุญาตและเสริมความปลอดภัยให้กับระบบ

1. พื้นฐานของ Linux File Permission

Linux ใช้ระบบสิทธิ์ 3 ระดับ คือ

Owner (ผู้เป็นเจ้าของ) คนที่สร้างไฟล์หรือโฟลเดอร์
Group (กลุ่ม) ผู้ใช้ที่อยู่ในกลุ่มเดียวกัน
Others (อื่น ๆ) ผู้ใช้ที่ไม่ได้เป็นทั้งเจ้าของหรืออยู่ในกลุ่ม

สิทธิ์แบ่งเป็น 3 ประเภท

Read (r) อ่านไฟล์/ดูรายชื่อไฟล์ในโฟลเดอร์
Write (w) แก้ไขไฟล์/เพิ่มหรือลบไฟล์ในโฟลเดอร์
Execute (x) รันไฟล์ที่เป็นสคริปต์หรือโปรแกรม/เข้าโฟลเดอร์

2. การดูสิทธิ์ของไฟล์หรือโฟลเดอร์

ใช้คำสั่ง ls -l เพื่อดูรายละเอียดไฟล์

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

-rwxr-xr--  1 user group  2048 Jan  5  example.sh

อธิบาย -rwxr-xr--

- ไฟล์ธรรมดา (หากเป็นโฟลเดอร์จะเป็น d)
rwx สิทธิ์ของ Owner (อ่าน, เขียน, รัน)
r-x สิทธิ์ของ Group (อ่าน, รัน)
r-- สิทธิ์ของ Others (อ่านเท่านั้น)

3. การเปลี่ยนสิทธิ์ของไฟล์ (chmod)

การกำหนดด้วยตัวอักษร

เพิ่มสิทธิ์

chmod u+x example.sh  # เพิ่มสิทธิ์รันให้ Owner
chmod g+w example.txt  # เพิ่มสิทธิ์เขียนให้ Group

ลบสิทธิ์

chmod o-r example.txt  # ลบสิทธิ์อ่านของ Others

การกำหนดด้วยเลขฐาน 8 (Octal) หรือ แบบ Numeric

เลข 3 หลักแทนสิทธิ์ (r=4, w=2, x=1)

7 (rwx) มีสิทธิ์ทั้งหมด
6 (rw-) อ่านและเขียน
5 (r-x) อ่านและรัน
4 (r--) อ่านอย่างเดียว

ตัวอย่างการใช้งาน

chmod 755 example.sh  # Owner=เต็มสิทธิ์, Group=อ่าน+รัน, Others=อ่าน+รัน
chmod 644 example.txt  # Owner=อ่าน+เขียน, Group=อ่าน, Others=อ่าน

การคำนวณแบบ Numeric สำหรับสิทธิ์ของไฟล์ใน Linux

Numeric Mode คือการใช้ตัวเลขฐานแปด (Octal) เพื่อแทนสิทธิ์ของไฟล์ใน Linux ซึ่งประกอบด้วย 3 ระดับคือ Owner, Group, และ Others
โดยแต่ละระดับประกอบด้วยสิทธิ์ 3 ประเภท Read (r), Write (w), และ Execute (x)

ตารางสิทธิ์ของไฟล์ใน Linux

สิทธิ์	คำอธิบาย	ค่าเลขฐานแปด
r	อ่าน (Read)	4
w	เขียน (Write)	2
x	รัน (Execute)	1
-	ไม่มีสิทธิ์	0

วิธีคำนวณ Numeric

แยกสิทธิ์ออกเป็น 3 กลุ่ม Owner, Group, และ Others
สำหรับแต่ละกลุ่ม
- นำค่าของ r, w, x มารวมกันตามสิทธิ์ที่กำหนด
- ถ้าไม่มีสิทธิ์ ให้ใช้ 0
รวมค่าของทั้ง 3 กลุ่มเข้าด้วยกันเป็นเลข 3 หลัก

ตัวอย่างการคำนวณ Numeric Mode

ตัวอย่างสิทธิ์
- -rwxr-xr--
แบ่งสิทธิ์

ตัวอย่างการคำนวณสิทธิ์ของไฟล์ใน Linux

กลุ่ม	สิทธิ์	ค่าตัวเลข
Owner	rwx	4 + 2 + 1 = 7
Group	r-x	4 + 0 + 1 = 5
Others	r--	4 + 0 + 0 = 4

รวมค่าของทั้ง 3 กลุ่ม
- Numeric Mode = 754

ตัวอย่างเพิ่มเติม

ตัวอย่างการคำนวณสิทธิ์ของไฟล์ใน Linux

สิทธิ์	Owner	Group	Others	Numeric Mode
-rw-r--r--	rw-	r--	r--	644
-rwx------	rwx	---	---	700
-rwxr-xr-x	rwx	r-x	r-x	755
-rw-rw----	rw-	rw-	---	660

4. การเปลี่ยนเจ้าของและกลุ่ม (chown และ chgrp)

เปลี่ยนเจ้าของไฟล์

chown user example.sh

เปลี่ยนกลุ่มของไฟล์

chgrp group example.sh

เปลี่ยนทั้งเจ้าของและกลุ่ม

chown user:group example.sh

5. ความสำคัญของ Special Permissions

SetUID (s)
- รันไฟล์ในฐานะเจ้าของไฟล์ ไม่ใช่ผู้รัน
- ใช้กับไฟล์โปรแกรม เช่น /usr/bin/passwd

chmod u+s example.sh

SetGID (s)
- กำหนดให้ไฟล์หรือโฟลเดอร์ใหม่ในกลุ่มเดียวกัน

chmod g+s folder/

Sticky Bit (t)
- กำหนดให้ลบไฟล์ในโฟลเดอร์ได้เฉพาะเจ้าของ

chmod +t /tmp

6. ตัวอย่างการตั้งค่าสิทธิ์ในสถานการณ์จริง

โฟลเดอร์ Public (อ่านได้ทุกคน)

chmod 755 /var/www/html/

ไฟล์ส่วนตัว (Owner เท่านั้นที่อ่านได้)

chmod 600 secret.txt

โฟลเดอร์ที่แชร์ในทีม

chmod 770 shared_folder/

สรุป

การจัดการ Permission ของไฟล์ใน Linux ช่วยให้ระบบมีความปลอดภัยและจัดการได้ง่ายขึ้น การเข้าใจคำสั่งพื้นฐาน เช่น chmod, chown, และ ls -l จะช่วยให้คุณสามารถบริหารจัดการสิทธิ์ได้ถูกต้อง

วิธีติดตั้งและกำหนดค่าเบื้องต้นสำหรับเซิร์ฟเวอร์ DNS บน Ubuntu 22.04 LTS แบบง่าย ๆ

Pargorn Ruasijan — Fri, 27 Dec 2024 09:28:00 +0000

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

ขั้นตอนที่ 1 ติดตั้ง BIND

อัปเดทและติดตั้ง BIND

sudo apt update && sudo apt install bind9

ขั้นตอนที่ 2 กำหนดค่าตัวเลือกของ BIND

แก้ไขไฟล์ named.conf.options เพื่อกำหนดค่าตัวเลือกของ BIND

sudo nano /etc/bind/named.conf.options

แก้ไขไฟล์ดังตัวอย่าง

options {
    directory "/var/cache/bind";

    // ถ้าต้องการดึงข้อมูลจากเซิร์ฟเวอร์ DNS อื่น
    forwarders {
        8.8.8.8;
        8.8.4.4;
    };

    // ที่อยู่ของ IP สำหรับการส่ง query DNS เข้ามา
    listen-on { 192.168.64.33; };

    // เปิดใช้งานการบันทึก query
    querylog yes;

    // อนุญาตให้ query จาก local
    allow-query { localhost; 192.168.64.0/24; };
};

ขั้นตอนที่ 3 กำหนดค่าโซนของโดเมน pargorn.com

แก้ไขข้อมูลโซน

sudo nano /etc/bind/named.conf.local

เพิ่มข้อมูลโซน

zone "pargorn.com" {
    type master;
    file "/etc/bind/db.pargorn.com";
};

ขั้นตอนที่ 4 สร้างไฟล์โซนของโดเมน pargorn.com

คัดลอกไฟล์ และแก้ไขไฟล์

sudo cp /etc/bind/db.local /etc/bind/db.pargorn.com
sudo nano /etc/bind/db.pargorn.com

แก้ไขไฟล์ db.pargorn.com

$TTL    604800
@       IN      SOA     ns.pargorn.com. root.pargorn.com. (
                              1         ; Serial
                         604800         ; Refresh
                          86400         ; Retry
                        2419200         ; Expire
                         604800 )       ; Negative Cache TTL
;
@       IN      NS      ns.pargorn.com.
ns      IN      A       192.168.64.33

บันทึกและปิดไฟล์ ### ขั้นตอนที่ 5 รีสตาร์ท BIND
รีสตาร์ท BIND เพื่อนำการเปลี่ยนแปลงไปใช้

sudo systemctl restart bind9

ขั้นตอนที่ 6 เพิ่ม DNS

เพิ่ม DNS IP Address

ขั้นตอนที่ 7 ทดสอบ DNS

ใช้เครื่องมือเช่น nslookup หรือ dig เพื่อทดสอบ DNS

nslookup ns.pargorn.com

เราได้ทำการติดตั้งและกำหนดค่าเซิร์ฟเวอร์ DNS บน Ubuntu เรียบร้อยแล้ว คุณสามารถปรับแต่งตามความต้องการของคุณได้ตามต้องการ

SQL Injection คืออะไร? และวิธีการป้องกัน

Pargorn Ruasijan — Thu, 26 Dec 2024 06:52:00 +0000

SQL Injection

เป็นการโจมตีด้านความปลอดภัยที่พบได้บ่อยในระบบฐานข้อมูลที่ใช้ SQL (Structured Query Language) เป็นภาษาสำหรับการจัดการฐานข้อมูล การโจมตีนี้เกิดจากการที่ Attacker ใส่โค้ด SQL ที่เป็นอันตรายลงในช่องทางการป้อนข้อมูลของผู้ใช้ เช่น ช่องกรอกแบบฟอร์ม หรือ URL เพื่อเข้าถึงหรือแก้ไขข้อมูลในฐานข้อมูลอย่างไม่ถูกต้อง

SQL Injection จัดอยู่อันดับที่ 3 ใน OWASP Top 10 ปี 2021 ซึ่งเป็นรายการของช่องโหว่ความปลอดภัยที่พบบ่อยและสำคัญที่สุดสำหรับเว็บแอปพลิเคชันที่จัดทำโดย Open Web Application Security Project (OWASP) รายการนี้มีการปรับปรุงทุกๆ หลายปีเพื่อสะท้อนถึงการเปลี่ยนแปลงของภัยคุกคามทางไซเบอร์

การโจมตีแบบ SQL Injection นั้นถูกจัดเป็นภัยคุกคามอันดับ 3 แสดงให้เห็นถึงความสำคัญและความแพร่หลายของปัญหานี้ในแง่ของความปลอดภัยของเว็บแอปพลิเคชัน การจัดการกับการโจมตีแบบ Injection อย่างถูกวิธีเป็นสิ่งจำเป็นในการรักษาความปลอดภัยของระบบข้อมูลและป้องกันการเข้าถึงที่ไม่พึงประสงค์

วิธีการโจมตี SQL Injection

การโจมตี SQL Injection สามารถทำได้หลากหลายรูปแบบ แต่หลักๆ จะมีสองวิธีที่พบได้บ่อย ได้แก่

การใส่ค่าเข้าไปในช่องทางป้อนข้อมูลโดยตรง
การแก้ไข URL เพื่อเพิ่มคำสั่ง SQL

ตัวอย่างการโจมตี SQL Injection

สมมติว่ามีเว็บแอปพลิเคชันที่ให้ผู้ใช้เข้าสู่ระบบ โดยมีโค้ด PHP

<?php
$username = $_POST['username'];
$password = $_POST['password'];

$query = "SELECT * FROM users WHERE username='$username' AND password='$password'";
$result = mysqli_query($conn, $query);

if (mysqli_num_rows($result) > 0) {
    echo "Login successful!";
} else {
    echo "Invalid username or password.";
}
?>

โค้ดนี้มีช่องโหว่เนื่องจากการใส่ค่าจากผู้ใช้เข้าไปในคำสั่ง SQL โดยตรง ทำให้เกิด SQL Injection ได้

การโจมตีโดยใช้ SQL Injection

แฮกเกอร์สามารถใส่ค่าที่เป็นอันตรายลงในช่องกรอกข้อมูล ดังนี้

ช่อง username ' OR '1'='1
ช่อง password ' OR '1'='1

ซึ่งจะทำให้คำสั่ง SQL เป็นดังนี้

SELECT * FROM users WHERE username='' OR '1'='1' AND password='' OR '1'='1'

เนื่องจาก '1'='1' เป็นเงื่อนไขที่เป็นจริงเสมอ คำสั่งนี้จะส่งคืนข้อมูลของผู้ใช้ทุกคนในฐานข้อมูล ทำให้แฮกเกอร์สามารถเข้าสู่ระบบได้โดยไม่ต้องใช้รหัสผ่านจริง

วิธีการป้องกัน SQL Injection

มีหลายวิธีที่สามารถป้องกัน SQL Injection ได้ เช่น

การใช้ Prepared Statements
การใช้ Stored Procedures
การกรองและตรวจสอบข้อมูลที่ป้อนเข้ามา ## ตัวอย่างการใช้ Prepared Statements ใน PHP

<?php
$stmt = $conn->prepare("SELECT * FROM users WHERE username=? AND password=?");
$stmt->bind_param("ss", $username, $password);

$username = $_POST['username'];
$password = $_POST['password'];

$stmt->execute();
$result = $stmt->get_result();

if ($result->num_rows > 0) {
    echo "Login successful!";
} else {
    echo "Invalid username or password.";
}
?>

ในตัวอย่างนี้ คำสั่ง SQL จะถูกเตรียมไว้ล่วงหน้า และค่า $username และ $password จะถูกใส่เข้าไปในคำสั่งนี้ภายหลัง ทำให้ไม่สามารถใส่โค้ด SQL ที่เป็นอันตรายเข้าไปได้

สรุป

SQL Injection เป็นภัยคุกคามที่ร้ายแรง แต่สามารถป้องกันได้ด้วยการเขียนโค้ดที่มีความปลอดภัย เช่น การใช้ Prepared Statements และการตรวจสอบข้อมูลที่ป้อนเข้ามา การป้องกันที่ดีไม่เพียงแต่ช่วยรักษาความปลอดภัยของข้อมูล แต่ยังช่วยรักษาความน่าเชื่อถือของระบบอีกด้วย

ทำความเข้าใจเกี่ยวกับ Big-O และตัวอย่างโค้ดในภาษา C++

Pargorn Ruasijan — Wed, 25 Dec 2024 07:10:00 +0000

Big-O Notation

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

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

O(1) - Constant Time

เส้นกราฟจะเป็นเส้นตรงแนวนอน ซึ่งหมายความว่าเวลาในการทำงานไม่เปลี่ยนแปลงตามขนาดของข้อมูล > การเข้าถึงค่าในอาร์เรย์โดยใช้เลขดัชนี (Index)

void constantTimeExample(int arr[], int size) {
    int value = arr[0];  // O(1)
}

O(log n) - Logarithmic Time

เส้นกราฟจะเป็นเส้นโค้งที่ค่อย ๆ เพิ่มขึ้น โดยมีอัตราการเพิ่มที่ลดลงเรื่อย ๆ
Binary Search

int binarySearch(int arr[], int size, int target) {
    int left = 0, right = size - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;  // O(log n)
        if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

เติบโตช้าเมื่อขนาดข้อมูลเพิ่มขึ้น

O(n) - Linear Time

เส้นกราฟจะเป็นเส้นตรงที่เพิ่มขึ้นตามขนาดของข้อมูล
Linear Search

int linearSearch(int arr[], int size, int target) {
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) return i;  // O(n)
    }
    return -1;
}

เติบโตเป็นเส้นตรงตามขนาดข้อมูล

O(n log n) - Linearithmic Time

เส้นกราฟจะเพิ่มขึ้นตามขนาดข้อมูลแบบไม่เป็นเส้นตรง และเร็วกว่าการเติบโตแบบเชิงเส้น
Merge Sort และ Quick Sort

void merge(int arr[], int left, int mid, int right) {
    // Merge two halves
}

void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);     // O(n log n)
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

เติบโตเร็วกว่า O(n) แต่ช้ากว่า O(n^2)

O(n^2) - Quadratic Time

เส้นกราฟจะเป็นเส้นโค้งที่เติบโตเร็วขึ้นตามขนาดข้อมูล
Bubble Sort

void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; ++i) {
        for (int j = 0; j < size - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);  // O(n^2)
            }
        }
    }
}

เติบโตเร็วขึ้นเรื่อย ๆ ตามขนาดข้อมูล

O(2^n) - Exponential Time

เส้นกราฟจะเป็นเส้นโค้งที่เติบโตอย่างรวดเร็วมาก ตามขนาดข้อมูลที่เพิ่มขึ้น
Fibonacci Recursive

int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);  // O(2^n)
}

เติบโตเร็วมากจนอาจไม่สามารถใช้งานได้เมื่อขนาดข้อมูลใหญ่

ความสัมพันธ์ของ Big-O

ลองจินตนาการถึงกราฟที่แสดงค่า Big-O ต่าง ๆ โดยแกน x แทนขนาดของข้อมูล (n) และแกน y แทนเวลาในการประมวลผล

O(1) เส้นตรงแนวนอนที่ค่าคงที่
O(log n) เส้นโค้งที่ค่อย ๆ เพิ่มขึ้นในอัตราลดลง (เช่น เส้นโค้งลอการิทึม)
O(n) เส้นตรงที่เพิ่มขึ้นอย่างสมมาตร
O(n log n) เส้นโค้งที่เพิ่มขึ้นอย่างรวดเร็วขึ้นจาก O(n) แต่ช้ากว่า O(n^2)
O(n^2) เส้นโค้งพาราโบลาที่เพิ่มขึ้นอย่างรวดเร็ว
O(2^n) เส้นโค้งที่เติบโตอย่างรวดเร็วมาก คล้ายเส้นเอ็กซ์โพเนนเชียล

สรุป

Big-O Notation เป็นเครื่องมือสำคัญในการวิเคราะห์และเปรียบเทียบประสิทธิภาพของอัลกอริธึม โดยช่วยให้เราสามารถตัดสินใจเลือกอัลกอริธึมที่มีประสิทธิภาพเหมาะสมกับงานที่ต้องการ โดยการเข้าใจประเภทต่าง ๆ ของ Big-O

สร้าง Dashboard ด้วย Grafana และ InfluxDB ด้วย Docker บน Ubuntu

Pargorn Ruasijan — Tue, 24 Dec 2024 07:07:00 +0000

ในบทความนี้เราจะมาสร้าง Dashboard ด้วย Grafana และ InfluxDB ด้วย Docker บน Ubuntu กัน !!!
ก่อนอื่นเรามาทำความรู้จักกับ Grafana และ InfluxDB กันก่อนครับ และเราจะใช้ Docker ในการสร้าง Container ของ Grafana และ InfluxDB

ทำความรู้จักกับ Grafana และ InfluxDB

Grafana

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

InfluxDB

เป็นฐานข้อมูลที่ออกแบบมาเพื่อการจัดเก็บและจัดการข้อมูลที่เกิดขึ้นตามเวลา (time series data) โดยเฉพาะ
ไม่ว่าจะเป็นข้อมูลจากเซนเซอร์, log data, หรือ metrics จากระบบคอมพิวเตอร์
InfluxDB มีความสามารถในการจัดการข้อมูลจำนวนมหาศาลได้อย่างรวดเร็วและมีประสิทธิภาพ

InfluxDB มีภาษา query ของตัวเองที่คล้ายกับ SQL ทำให้ง่ายต่อการใช้งานและการเรียนรู้

ตัวอย่างภาษา query ของ InfluxDB

เราสามารถเลือกข้อมูลในช่วงเวลาที่ต้องการ เช่น ข้อมูลอุณหภูมิในช่วง 24 ชั่วโมงที่ผ่านมา

SELECT * FROM temperature WHERE time > now() - 24h

เราสามารถใช้ฟังก์ชันเชิงรวมเพื่อคำนวณค่าเฉลี่ย, ค่าสูงสุด, หรือต่ำสุดของข้อมูลได้ เช่น คำนวณค่าเฉลี่ยของอุณหภูมิในช่วง 24 ชั่วโมงที่ผ่านมา

SELECT MEAN(value) FROM temperature WHERE time > now() - 24h

เราสามารถจัดกลุ่มข้อมูลตามเวลาเพื่อดูการเปลี่ยนแปลงของข้อมูลในแต่ละช่วงเวลา เช่น ค่าเฉลี่ยของอุณหภูมิทุกๆ 1 ชั่วโมง ในช่วง 24 ชั่วโมงที่ผ่านมา

SELECT MEAN(value) FROM temperature WHERE time > now() - 24h GROUP BY time(1h)

ตัวอย่างภาษา query ของ InfluxDB รูปแบบ Flux

Flux เป็นภาษา query ใหม่ของ influxdb

from(bucket: "mydb/autogen")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "cpu")
  |> filter(fn: (r) => r.cpu == "cpu-total")
  |> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
  |> yield(name: "mean")

query นี้ดึงข้อมูลจาก bucket mydb/autoge ในช่วง 1 ชั่วโมงที่ผ่านมา โดยกรองข้อมูลที่มี _measurement เป็น "cpu" และ cpu เป็น "cpu-total" จากนั้นคำนวณค่าเฉลี่ยทุก ๆ 1 นาที และส่งผลลัพธ์ออกมาด้วยชื่อ "mean"

ขั้นตอนการติดตั้ง

อัปเดตแพคเกจของ Ubuntu

sudo apt-get update && sudo apt-get upgrade

ติดตั้ง Docker บน Ubuntu

Set up apt repository

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

ติดตั้ง Docker packages

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

ตรวจสอบการติดตั้ง Docker

sudo docker --version

ถ้าหากใช้คำสั่ง sudo docker --version แล้วขึ้นเลขเวอร์ชันของ Docker แสดงว่าการติดตั้งสำเร็จ

การติดตั้ง และสร้างไฟล์ Docker Compose

ติดตั้ง Docker Compose

sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

ตรวจสอบการติดตั้ง Docker Compose

docker-compose --version

สร้างไฟล์ docker-compose.yml ด้วยคำสั่ง

touch docker-compose.yml

แก้ไขไฟล์ docker-compose.yml ด้วยโปรแกรมที่ต้องการ เช่น nano, vim, หรือ Visual Studio Code

nano docker-compose.yml

แก้ไขไฟล์ docker-compose.yml ด้วยโค้ดด้านล่าง

version: '3.1'

services:
  influxdb:
    image: influxdb:latest
    container_name: influxdb
    ports:
      - "8086:8086"
    environment:
      - INFLUXDB_DB=mydatabase
      - INFLUXDB_ADMIN_USER=admin
      - INFLUXDB_ADMIN_PASSWORD=adminpassword
    volumes:
      - influxdb-data:/var/lib/influxdb

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=adminpassword
    volumes:
      - grafana-data:/var/lib/grafana

volumes:
  influxdb-data:
  grafana-data:

รัน Container ด้วย Docker Compose

รันคำสั่งเพื่อสร้าง Container จากไฟล์ docker-compose.yml

sudo docker-compose up -d

-d คือคำสั่งที่ใช้ในการรัน Container ในโหมด background (จะรัน Container ตลอดเวลา)

การตั้งค่า InfluxDB

หลังจากที่ Container ของ InfluxDB รันเสร็จแล้ว ให้เข้าไปที่ http://localhost:8086 หรือ http://server-ip:8086 ในเว็บเบราวเซอร์

ตั้งค่า Username, Password, Organization, Bucket

เมื่อตั้งค่าเสร็จแล้ว คุณจะได้ API Token มา ให้เก็บไว้เพื่อใช้ในการเชื่อมต่อกับ Grafana

การตั้งค่า Grafana

เข้าไปที่ http://localhost:3000 หรือ http://server-ip:8086 ในเว็บเบราวเซอร์ แล้วเข้าสู่ระบบด้วยข้อมูลผู้ใช้ admin และรหัสผ่าน adminpassword ที่ได้กำหนดไว้ในไฟล์ docker-compose.yml

เพิ่ม Data Source

ให้ไปที่ Connection -> Data Source แล้วเลือก InfluxDB

เลือก Query Language เป็น Flux

ตั้งค่า URL ให้เป็น http://localhost:8086 หรือ http://server-ip:8086

เปิดใช้งาน Basic Auth และกรอก Username และ Password ให้ตรงกับที่ได้ตั้งค่าใน docker-compose.yml

กรอกข้อมูล Organization, Bucket, Token ที่ได้จากการตั้งค่า InfluxDB

คลิก Save & Test เพื่อทดสอบการเชื่อมต่อ

ถ้าหากขึ้นข้อความ Data source is working แสดงว่าการเชื่อมต่อสำเร็จ !!!

สร้าง Dashboard

สร้าง Dashboard ใหม่

ให้ไปที่เมนู Dashboards -> Create Dashboard

กด Add visualization เพื่อเพิ่มกราฟ และเลือก Data Source ที่เราตั้งค่าไว้

ช่องสำหรับเขียน Query เพื่อดึงข้อมูลจาก InfluxDB มาแสดงผลเป็นกราฟ

เพิ่มข้อมูลใน InfluxDB เพื่อทดสอบ

หลักจากที่เราได้ตั้งค่าทุกอย่างเสร็จเรียบร้อยแล้ว ให้เข้าไปที่ http://localhost:8086 หรือ http://server-ip:8086 ในเว็บเบราวเซอร์ เพื่อเข้าไปเพิ่มข้อมูลใน InfluxDB ของเรากัน
ตอนนี้ Bucket ของเราจะว่างเปล่าอยู่ ให้เราเพิ่มข้อมูลเข้าไปเพื่อนำไปแสดงผลใน Grafana

ให้กดที่ `Data Explorer` แล้วเลือก `Bucket` ที่เราตั้งค่าไว้ และกดไปที่ `Script Editor`

ใช้สคริปต์ Flux เพื่อเพิ่มข้อมูลจำลองเข้าไปใน Bucket ของเรา

import "experimental"
import "array"

data = array.from(rows: [
  {_time: experimental.addDuration(d: -10m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 1},
  {_time: experimental.addDuration(d: -9m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 2},
  {_time: experimental.addDuration(d: -8m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 3},
  {_time: experimental.addDuration(d: -7m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 4},
  {_time: experimental.addDuration(d: -6m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 5},
  {_time: experimental.addDuration(d: -5m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 6},
  {_time: experimental.addDuration(d: -4m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 7},
  {_time: experimental.addDuration(d: -3m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 8},
  {_time: experimental.addDuration(d: -2m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 9},
  {_time: experimental.addDuration(d: -1m, to: now()), _measurement: "measurement", tag1: "value1", _field: "field1", _value: 10}
])

data
  |> to(bucket: "test")

สคริปต์นี้จะสร้างข้อมูลจำลอง 10 แถวใน bucket test โดยมีเวลาเป็นช่วงเวลาที่แตกต่างกันภายใน 10 นาทีที่ผ่านมา และค่า field1 เป็นตัวเลขตั้งแต่ 1 ถึง 10

หลังจากนั้นกด Submit เพื่อเพิ่มข้อมูลเข้าไปใน Bucket

เมื่อไม่มีอะไรผิดพลาดขึ้น ข้อมูลจะถูกเพิ่มเข้าไปใน Bucket ของเรา และจะแสดงเส้นกราฟใน Data Explorer

Query ข้อมูลจาก InfluxDB ใน Grafana

ให้เพิ่มคำสั่ง Query ใน Visualization ของเรา

from(bucket: "test")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "measurement")
  |> filter(fn: (r) => r.tag1 == "value1")
  |> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
  |> yield(name: "mean")

อธิบายการทำงานของคำสั่ง

from(bucket: "test")
- เลือก bucket ชื่อ test เป็นแหล่งข้อมูลเริ่มต้นที่จะทำการ query
|> range(start: -1h)
- กำหนดช่วงเวลาของข้อมูลที่ต้องการดึงมา โดยจะดึงข้อมูลตั้งแต่ 1 ชั่วโมงที่ผ่านมาจนถึงปัจจุบัน
- -1h หมายถึง 1 ชั่วโมงที่ผ่านมาจากเวลาปัจจุบัน
|> filter(fn: (r) => r._measurement == "measurement")
- กรองข้อมูลให้เหลือเฉพาะที่ _measurement มีค่าเป็น "measurement"
- ฟังก์ชั่น filter จะทำการประเมินเงื่อนไข fn: (r) => r._measurement == "measurement" โดย r คือแต่ละแถวของข้อมูล
|> filter(fn: (r) => r.tag1 == "value1")
- กรองข้อมูลเพิ่มเติมให้เหลือเฉพาะที่ tag1 มีค่าเป็น "value1"
|> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
- ทำการรวมข้อมูลในช่วงเวลาที่กำหนดโดยใช้ฟังก์ชั่น mean (ค่าเฉลี่ย)
- every: 1m หมายถึงช่วงเวลา 1 นาที
- createEmpty: false หมายถึงไม่สร้างช่วงเวลาที่ไม่มีข้อมูล
|> yield(name: "mean")
- ส่งผลลัพธ์ออกมาโดยใช้ชื่อ "mean"
- yieldเป็นคำสั่งที่บอกให้ query สิ้นสุดและส่งผลลัพธ์

ตัวอย่างตารางของข้อมูล

_time	_value
2024-06-01T12:00:00Z	10.5
2024-06-01T12:01:00Z	11.0
2024-06-01T12:02:00Z	10.2

บันทึกการตั้งค่า

กด Apply เพื่อบันทึกการตั้งค่า
เราก็จะได้ข้อมูลจาก InfluxDB มาแสดงผลใน Grafana เรียบร้อย

คุณสามารถเปลี่ยนรูปแบบของกราฟได้โดยกดไปที่ Visualization และเลือกรูปแบบที่ต้องการ

สรุป

ในบทความนี้เราได้เรียนรู้วิธีการสร้าง Dashboard ด้วย Grafana และ InfluxDB ด้วย Docker บน Ubuntu
และเราได้ทำการตั้งค่าและเชื่อมต่อ Grafana กับ InfluxDB และสร้าง Dashboard แสดงผลข้อมูลจาก InfluxDB ได้เรียบร้อย ไว้เจอกันใน Blog ต่อไปครับ 👋👋👋

วิธีทำ Auth API ด้วย Express, JWT, MySQL และ Prisma

Pargorn Ruasijan — Tue, 24 Dec 2024 06:55:00 +0000

การสร้าง Auth API ด้วย JWT และ MySQL โดยใช้ Prisma สำหรับการจัดการฐานข้อมูล
จะมีการแยกส่วนประกอบออกเป็นไฟล์ต่างๆ เพื่อความสะดวกในการแก้ไข
โดยในตัวอย่างนี้ เราจะใช้ Node.js กับ Express.js สำหรับ backend และ JWT สำหรับการจัดการ token
พร้อมด้วย Prisma สำหรับการจัดการกับฐานข้อมูล MySQL

ขั้นตอนการติดตั้งและตั้งค่า

mkdir auth-api
cd auth-api

สร้างโปรเจค Node.js และติดตั้ง package ที่ใช้

npm init -y
npm install express prisma @prisma/client jsonwebtoken bcryptjs body-parser

ตั้งค่า Prisma

npx prisma init

ตั้งค่าไฟล์ Prisma schema

prisma/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

model User {
  id       Int      @id @default(autoincrement())
  username String   @unique
  password String
}

ตั้งค่าไฟล์ .env

user ชื่อผู้ใช้ของ MySQL
password รหัสผ่านของ MySQL
localhost:3306 ที่อยู่ของ MySQL
auth_db ชื่อฐานข้อมูลที่จะใช้

DATABASE_URL="mysql://user:password@localhost:3306/auth_db"

สร้างฐานข้อมูลและตาราง

npx prisma migrate dev --name init

สร้างไฟล์และโฟลเดอร์ต่างๆ

touch server.js config.js routes.js
mkdir controllers models middlewares
touch controllers/authController.js middlewares/middleware.js

โครงสร้างโปรเจค

auth-api/
├── controllers/
│   └── authController.js
├── middlewares/
│   └── middleware.js
├── models/
│   └── userModel.js
├── prisma/
│   ├── migrations/
│   │   └── <migration files>
│   ├── schema.prisma
├── .env
├── config.js
├── package.json
├── routes.js
├── server.js

เขียนโค้ดสำหรับแต่ละไฟล์

server.js

const express = require('express'); // เรียกใช้งาน express เพื่อสร้าง server
const bodyParser = require('body-parser'); // เรียกใช้งาน body-parser เพื่อแปลงข้อมูลที่ส่งมาให้เป็น JSON
const routes = require('./routes'); // เรียกใช้งานไฟล์ routes.js ที่เราสร้างไว้เพื่อใช้ในการกำหนดเส้นทางของ API

const app = express(); // สร้าง instance ของ express
const PORT = process.env.PORT || 3000; // กำหนด port ที่จะใช้ในการรัน server

app.use(bodyParser.json()); // ใช้ body-parser ในการแปลงข้อมูลที่ส่งมาให้เป็น JSON
app.use('/api', routes); // กำหนดเส้นทางของ API

app.listen(PORT, () => { // รัน server ที่ port ที่กำหนด
    console.log(`Server is running on port ${PORT}`);
});

config.js

module.exports = {
    jwtSecret: 'your-secret-key' // กำหนด secret key สำหรับการสร้าง token
};

models/userModel.js

const { PrismaClient } = require('@prisma/client'); // เรียกใช้งาน PrismaClient จาก @prisma/client
const prisma = new PrismaClient(); // สร้าง instance ของ PrismaClient
const bcrypt = require('bcryptjs'); // เรียกใช้งาน bcryptjs เพื่อใช้ในการเข้ารหัสรหัสผ่าน

// สร้างผู้ใช้ใหม่
const createUser = async (user) => {
    // เข้ารหัสรหัสผ่านก่อนที่จะเก็บไว้ในฐานข้อมูล
    const hash = await bcrypt.hash(user.password, 10);
    // บันทึกข้อมูลผู้ใช้ลงในฐานข้อมูล
    return prisma.user.create({
        data: {
            username: user.username,
            password: hash
        }
    });
};

// ค้นหาผู้ใช้จากชื่อผู้ใช้
const findUserByUsername = async (username) => {
    return prisma.user.findUnique({
        where: { username: username }
    });
};

module.exports = {
    createUser,
    findUserByUsername
};

controllers/authController.js

const jwt = require('jsonwebtoken'); // เรียกใช้งาน jwt เพื่อใช้ในการสร้าง token
const bcrypt = require('bcryptjs'); // เรียกใช้งาน bcryptjs เพื่อใช้ในการเข้ารหัสรหัสผ่าน
const config = require('../config'); // เรียกใช้งานไฟล์ config.js ที่เราสร้างไว้
const User = require('../models/userModel'); // เรียกใช้งาน userModel.js ที่เราสร้างไว้

const register = async (req, res) => {
    const { username, password } = req.body; // รับข้อมูล username และ password จาก body ของ request
    // สร้างผู้ใช้ใหม่
    try {
        await User.createUser({ username, password });
        res.status(201).json({ message: 'User registered successfully' });
    } catch (err) { // หากเกิดข้อผิดพลาดในการสร้างผู้ใช้
        res.status(500).json({ message: 'Error registering user' });
    }
};

const login = async (req, res) => {
    const { username, password } = req.body; // รับข้อมูล username และ password จาก body ของ request
    try {
        const user = await User.findUserByUsername(username); // ค้นหาผู้ใช้จากชื่อผู้ใช้
        if (!user) { // หากไม่พบผู้ใช้
            return res.status(401).json({ message: 'Invalid username or password' });
        }
        // หากรหัสผ่านไม่ตรงกับที่เก็บไว้ในฐานข้อมูล
        const isMatch = await bcrypt.compare(password, user.password);
        if (!isMatch) {
            return res.status(401).json({ message: 'Invalid username or password' });
        }
        // สร้าง token และส่งกลับไปให้ผู้ใช้
        const token = jwt.sign({ id: user.id }, config.jwtSecret, { expiresIn: '1h' });
        res.json({ token });
    } catch (err) { // หากเกิดข้อผิดพลาดในการเข้าสู่ระบบ
        res.status(500).json({ message: 'Error logging in' });
    }
};

module.exports = {
    register,
    login
};

middlewares/middleware.js

const jwt = require('jsonwebtoken'); // เรียกใช้งาน jwt เพื่อใช้ในการตรวจสอบ token
const config = require('../config'); // เรียกใช้งานไฟล์ config.js ที่เราสร้างไว้

// next คือ callback function ที่ใช้ในการส่งต่อไปยัง middleware ถัดไป
const verifyToken = (req, res, next) => { // middleware สำหรับตรวจสอบ token
    const token = req.headers['authorization']; // รับ token จาก header ของ request
    if (!token) return res.status(403).json({ message: 'No token provided' }); // หากไม่มี token ให้ส่งข้อความกลับไปว่าไม่มี token

    jwt.verify(token, config.jwtSecret, (err, decoded) => { // ตรวจสอบ token
        if (err) return res.status(500).json({ message: 'Failed to authenticate token' }); // หากไม่สามารถตรวจสอบ token ได้ให้ส่งข้อความกลับไปว่าไม่สามารถตรวจสอบ token ได้

        req.userId = decoded.id; // ถ้าตรวจสอบ token สำเร็จ ให้เก็บ id ของผู้ใช้ไว้ใน req.userId
        next(); // ส่งต่อไปยัง middleware ถัดไป
    });
};

module.exports = {
    verifyToken
};

routes.js

const express = require('express'); // เรียกใช้งาน express
const authController = require('./controllers/authController'); // เรียกใช้งาน authController.js ที่เราสร้างไว้
const middleware = require('./middlewares/middleware'); // เรียกใช้งาน middleware.js ที่เราสร้างไว้

const router = express.Router(); // สร้าง instance ของ express.Router

router.post('/register', authController.register); // สร้างเส้นทางสำหรับการลงทะเบียนผู้ใช้
router.post('/login', authController.login); // สร้างเส้นทางสำหรับการเข้าสู่ระบบ

// Protected route example
router.get('/protected', middleware.verifyToken, (req, res) => { // สร้างเส้นทางสำหรับการตรวจสอบ token
    res.json({ message: 'This is a protected route', userId: req.userId }); // ส่งข้อความกลับไปว่านี่คือเส้นทางที่ถูกป้องกัน
});

module.exports = router;

รัน server

node server.js

เราสามารถทดสอบ API ด้วย Postman หรือ Thunder Client โดยการสร้าง request ไปที่ http://localhost:3000/api/register และ http://localhost:3000/api/login และส่งข้อมูล username และ password ไปด้วย

ตัวอย่าง request สำหรับ route register

/api/register

{
    "username": "john_doe",
    "password": "password123"
}

Response

{
    "message": "User registered successfully"
}

ตัวอย่าง request สำหรับ route login

/api/login

{
    "username": "john_doe",
    "password": "password123"
}

Response

{
    "token": "token-string"
}

ตัวอย่าง request สำหรับ route protected

/api/protected

// ใส่ token ใน header ของ request
{
    "Authorization": "token-string"
}

Response

{
    "message": "This is a protected route",
    "userId": 1
}

นอกจากนี้เรายังสามารถใช้งาน Prisma Studio เพื่อดูข้อมูลในฐานข้อมูลได้ด้วย

npx prisma studio

สามารถดูตัวอย่างโค้ดทั้งหมดได้จาก GitHub
หรือสามารถดูตัวอย่างการทำงานได้จาก YouTube

การทำ HTTPS ด้วย Certbot และ Nginx บน Ubuntu Server

Pargorn Ruasijan — Tue, 24 Dec 2024 06:44:00 +0000

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

สิ่งที่ต้องมี

เซิร์ฟเวอร์ Ubuntu แนะนำ Ubuntu 20.04 LTS หรือเวอร์ชันล่าสุด
Nginx หากยังไม่มี สามารถติดตั้งได้ตามขั้นตอนในบทความนี้
โดเมนเนมที่ชี้ไปยังเซิร์ฟเวอร์ของคุณ เช่น example.com และมี DNS records ชี้ไปยัง IP ของเซิร์ฟเวอร์
สิทธิ์การเข้าถึงแบบ root หรือผู้ใช้ที่มีสิทธิ์ sudo บนเซิร์ฟเวอร์

วิธีการชี้โดเมนไปยัง IP ของเซิร์ฟเวอร์

เพิ่ม DNS records สำหรับโดเมน certbot.pargorn.com ที่ชี้ไปยัง IP ของเซิร์ฟเวอร์
เลือก A record และใส่ IP ของเซิร์ฟเวอร์

ขั้นตอนที่ 1 อัปเดตระบบ

เริ่มต้นด้วยการอัปเดตแพคเกจของระบบให้เป็นเวอร์ชันล่าสุด

sudo apt update
sudo apt upgrade -y

ขั้นตอนที่ 2 ติดตั้ง Nginx

หากยังไม่ได้ติดตั้ง Nginx สามารถติดตั้งได้ด้วยคำสั่ง

sudo apt install nginx -y

หลังจากติดตั้งเสร็จสิ้น ตรวจสอบให้แน่ใจว่า Nginx ทำงานอยู่
คุณควรเห็นสถานะ active (running) ถ้า Nginx ทำงานถูกต้อง

ขั้นตอนที่ 3 สร้างเว็บไซต์ “Hello Certbot”

เราจะสร้างเว็บไซต์ง่ายๆ ที่แสดงข้อความ “Hello Certbot” สำหรับโดเมน certbot.pargorn.com

1. สร้างไดเรกทอรีสำหรับเว็บไซต์

sudo mkdir -p /var/www/certbot.pargorn.com/html

2. กำหนดสิทธิ์ให้กับไดเรกทอรี

sudo chown -R $USER:$USER /var/www/certbot.pargorn.com/html
sudo chmod -R 755 /var/www/certbot.pargorn.com

3. สร้างไฟล์ HTML สำหรับเว็บไซต์

สร้างไฟล์ index.html ที่จะแสดงข้อความ “Hello Certbot”

nano /var/www/certbot.pargorn.com/html/index.html

4. จากนั้นเพิ่มเนื้อหาดังนี้

บันทึกไฟล์โดยกด Ctrl + O แล้วออกจาก nano ด้วย Ctrl + X

<!DOCTYPE html>
<html>
<head>
    <title>Hello Certbot</title>
</head>
<body>
    <h1>Hello Certbot</h1>
</body>
</html>

5. สร้างไฟล์การตั้งค่าเซิร์ฟเวอร์สำหรับ Nginx

สร้างไฟล์การตั้งค่าสำหรับเว็บไซต์ certbot.pargorn.com

sudo nano /etc/nginx/sites-available/certbot.pargorn.com

6. เพิ่มเนื้อหาดังนี้

บันทึกไฟล์โดยกด Ctrl + O แล้วออกจาก nano ด้วย Ctrl + X

server {
    listen 80;
    listen [::]:80;

    server_name certbot.pargorn.com;

    root /var/www/certbot.pargorn.com/html;
    index index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }
}

7. เปิดใช้งานการตั้งค่าเว็บไซต์

สร้าง symbolic link ไปยัง sites-enabled เพื่อเปิดใช้งานเว็บไซต์

sudo ln -s /etc/nginx/sites-available/certbot.pargorn.com /etc/nginx/sites-enabled/

8. ทดสอบการตั้งค่าของ Nginx

sudo nginx -t

9. หากไม่มีข้อผิดพลาด ให้รีสตาร์ท Nginx

sudo systemctl reload nginx

10. ตรวจสอบว่าเว็บไซต์ “Hello Certbot” ทำงานอยู่หรือไม่

เปิดเว็บเบราว์เซอร์และเข้าไปที่ http://certbot.pargorn.com

ขั้นตอนที่ 4 ติดตั้ง Certbot

Certbot เป็นเครื่องมือที่ช่วยให้การขอและต่ออายุ SSL Certificates จาก Let’s Encrypt เป็นเรื่องง่าย ในการติดตั้ง Certbot สำหรับ Nginx บน Ubuntu

sudo apt install certbot python3-certbot-nginx -y

ขั้นตอนที่ 5 ขอรับ SSL Certificate ด้วย Certbot

หลังจากติดตั้งเสร็จสิ้น สามารถใช้ Certbot ในการขอรับ SSL Certificate ได้โดยใช้คำสั่ง

sudo certbot --nginx -d certbot.pargorn.com

Certbot จะถามข้อมูลต่างๆ ดังนี้

อีเมลสำหรับการแจ้งเตือน ใส่อีเมลที่สามารถติดต่อได้เพื่อรับการแจ้งเตือนเกี่ยวกับ SSL Certificate
ยอมรับข้อตกลงการให้บริการ
เลือกโดเมนที่ต้องการเปิดใช้งาน HTTPS ในที่นี้จะเลือก certbot.pargorn.com
เลือกว่าจะทำการเปลี่ยนเส้นทางทั้งหมดจาก HTTP เป็น HTTPS หรือไม่ แนะนำให้เลือกให้เปลี่ยนเส้นทางทั้งหมด

ตัวอย่าง

Which names would you like to activate HTTPS for?
- certbot.pargorn.com

Please choose whether or not to redirect HTTP traffic to HTTPS,
removing HTTP access. Your web traffic will then only be available
through HTTPS.

1: No redirect - Make no further changes to the webserver configuration
2: Redirect - Make all requests redirect to secure HTTPS access.
   Choose this for simple HTTPS setups.

Select the appropriate number [1-2] then [enter] (default: 2):

ขั้นตอนที่ 6 ตรวจสอบการตั้งค่า Nginx

Certbot จะปรับแต่งไฟล์การตั้งค่า Nginx ให้รองรับ HTTPS โดยอัตโนมัติ แต่คุณสามารถตรวจสอบได้ที่ไฟล์การตั้งค่าใน /etc/nginx/sites-available/certbot.pargorn.com

server {
    listen 80;
    listen [::]:80;
    server_name certbot.pargorn.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    server_name certbot.pargorn.com;

    ssl_certificate /etc/letsencrypt/live/certbot.pargorn.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/certbot.pargorn.com/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    root /var/www/certbot.pargorn.com/html;
    index index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }
}

หลังจากตรวจสอบแล้ว ให้ทดสอบการตั้งค่าของ Nginx

sudo nginx -t

ถ้าการตั้งค่าถูกต้อง ให้รีสตาร์ท Nginx

sudo systemctl reload nginx

ขั้นตอนที่ 7 ทดสอบเว็บไซต์ด้วย HTTPS

เปิดเว็บเบราว์เซอร์และเข้าไปที่ https://certbot.pargorn.com คุณควรเห็น ไอคอนรูปกุญแจล็อก 🔒 ที่แสดงถึงการเชื่อมต่อที่ปลอดภัย พร้อมทั้งหน้าเว็บที่แสดงข้อความ “Hello Certbot” หากไม่มีข้อผิดพลาดใดๆ เกิดขึ้น แสดงว่าการตั้งค่า HTTPS สำเร็จเรียบร้อยแล้ว

ขั้นตอนที่ 8 ตั้งค่าการต่ออายุอัตโนมัติสำหรับ SSL Certificate

SSL Certificates จาก Let’s Encrypt มีอายุ 90 วัน คุณสามารถตั้งค่าให้ Certbot ต่ออายุอัตโนมัติได้ด้วยการเพิ่ม Cron Job หรือใช้ systemd timer ที่มาพร้อมกับ Certbot
ตรวจสอบให้แน่ใจว่า Cron Job สำหรับ Certbot มีอยู่

sudo systemctl list-timers | grep certbot

โดยปกติ Certbot จะตั้งค่าให้ทำการตรวจสอบและต่ออายุอัตโนมัติทุกวัน หากต้องการตรวจสอบการต่ออายุสามารถทำได้ด้วยคำสั่ง
ถ้าไม่มีข้อผิดพลาด แสดงว่าการตั้งค่าการต่ออายุอัตโนมัติทำงานได้ถูกต้อง

sudo certbot renew --dry-run

สรุป

การติดตั้งและกำหนดค่า HTTPS บน Nginx ด้วย Certbot บน Ubuntu Server เป็นกระบวนการที่ไม่ซับซ้อนและสามารถทำได้ในไม่กี่ขั้นตอน การใช้ HTTPS จะช่วยเพิ่มความปลอดภัยให้กับเว็บไซต์ของคุณและสร้างความเชื่อมั่นให้กับผู้ใช้งาน ในบทความนี้เราได้สร้างเว็บไซต์ที่แสดงข้อความ “Hello Certbot” และใช้โดเมน certbot.pargorn.com เพื่อแสดงให้เห็นถึงการตั้งค่าอย่างครบถ้วน อย่าลืมตรวจสอบและต่ออายุ SSL Certificates อย่างสม่ำเสมอเพื่อรักษาความปลอดภัยของเว็บไซต์อย่างต่อเนื่อง