เตรียมพร้อม Deploy API Gateway และ Monitoring Microservices ด้วย Kong และ Grafana

บทความนี้จะมาแนะนำวิธีการ Deploy Kong โดยทำเป็น API Gateway บน Docker ครับ (โดยที่ Kong สามารถรันได้บนแพลตฟอร์มที่หลากหลาย ทั้งบน Cloud, On-Premise อีกทั้งยัง Deploy ครอบคลุมทุกการใช้งาน อาทิ เช่น Binary, Docker หรือ Kuberbetes) เป็นต้น.

ก่อนอื่นเราต้องสร้าง Environment บน Platform-as-a-service (PaaS) ขึ้นมาเพื่อติดตั้ง Docker Engine CE (Standalone engine) สำหรับ Build Container โดยเราจะสร้าง Containers เอาไว้ใน Host เดียวกัน ซึ่งประกอบไปด้วย Kong, Postgress, Mongo, Konga, Grafana และ Prometheus.

หมายเหตุ

บทความนี้เราจะ Deploy โปรเจค บน Docker Container
บทความนี้เราเก็บไฟล์ source code ไว้ที่ Gitlab
บทความนี้เราใช้งาน Docker Engine CE บน PaaS
บทความนี้สร้าง Container และ Config ด้วย Docker-compose บน Docker Engine CE

Kong คืออะไร… อีหวังว่ะ Kong?

Kong ทำหน้าที่เป็น API Gateway ซึ่ง Kong มี 2 เวอร์ชั่นคือ CE (Community Edition) และ EE (Enterprise Edition) Kong เป็นจุดศูนย์รวมของการควบคุมการเข้าถึงเซิร์ฟเวอร์ Internal API ที่เราเปิด Public ให้ผู้ใช้ภายนอกเรียกใช้งานครับ เช่น ธนาคาร เปิด API Banking ให้พาร์เนอร์หรือคู่ค้ามาเชื่อมต่อได้ ทำให้เราสามารถทำงานต่าง ๆ อย่าง เช่น การทำ Authentication เพื่อยืนยันตัวตนก่อนเข้าใช้ Service การทำ Rate Limiting เพื่อควบคุม Traffic ได้ว่าใน 1 วินาที/นาที/ชั่วโมง/วัน จะมี Request ได้กี่ครั้ง หรือการทำ Monitoring Service ร่วมกับ Prometheus และ Grafana เป็นต้น.

Kong Architecture

image credit: https://medium.com/devopsturkiye/kong-api-gateway-installing-configuring-and-securing-dfea423ee53c

Kong is a scalable, open-source API Layer (also known as an API Gateway, or API Middleware). Kong runs in front of any RESTful API and is extended through Plugins, which provide extra functionality and services beyond the core platform.

สำหรับ Kong ในเวอร์ชั่นแรก ๆ จำเป็นที่จะต้องมีฐานข้อมูลสำหรับเก็บค่าคอนฟิกต่าง ๆ ของ Gateway ซึ่ง Kong รองรับการใช้งานฐานข้อมูล 2 ตัวคือ PostgreSQL และ Cassandra ซึ่งมันก็ขึ้นอยู่กับการนำไปใช้งานของแต่ล่ะคนตามความต้องการของระบบครับ.

สำหรับซอฟต์แวร์ Kong version 1.1 มันจะเก็บคอนฟิกต่าง ๆ ลงบนฐานข้อมูลและยังสามารถใช้งาน Kong แบบไม่ต้องมีฐานข้อมูลก็ได้ (โดยวิธีการใช้ไฟล์คอนฟิกแทน เรียกโหมดนี้ว่า Kong DB-less) ข้อดีก็คือ ไม่ต้องดูแลฐานข้อมูลครับ ส่วนข้อเสียคือ อาจมีบางปลั๊กอินไม่รองรับการทำงาน.

credit image: https://medium.com/devopsturkiye/kong-api-gateway-installing-configuring-and-securing-dfea423ee53c

การใช้ Kong DB-less แบบกระจายคอนฟิกไปยังโหนดต่าง ๆ เช่น Kong Ingress บน Kubernetes หรือ รัน Kong DB-less ที่เอาไฟล์คอนฟิกมาจากที่เดียวกัน โดยในโหมดนี้จะมี Kong รันอยู่ 2 role คือ

Control plane
และ Data plane

Control Plane จะเป็น Kong ที่รันด้วยโหมดที่มีฐานข้อมูล เหมือน Kong ปกติ มี Admin API ให้ใช้งาน ทำหน้าที่กระจายคอนฟิกไปยังโหนดในคลัสเตอร์ เรียกว่า Data Plane

Data Plane คือ Kong Proxy ที่รันเป็น Kong DB-less โดยจะมีการอัปเดตคอนฟิกเมื่อมีการเปลี่ยนแปลงที่ Control Plane อีกที

(ในบทความนี้เราใช้ฐานข้อมูล PostgreSQL)

Kong เป็น API Gateway ที่ได้รับความนิยมเป็นอย่างมาก โดยเฉพาะการนำมาใช้กับ architecture ระบบสมัยใหม่ที่เรียกว่า Microservice โดยการตั้งค่า Kong สามารถแบ่งเป็นสองส่วนคือฝั่ง Client และ Admin ซึ่งในส่วนของ Admin เราได้พูดถึง main components หลับก ๆ อยู่ 4 อย่างคือ

Kong Admin API Components

1. Service คือ Service ปลายทางที่ต้องการให้ Kong ส่งต่อ Request ไปหา (route)
เช่น User service, Payment service และ Cart service เป็นต้น.

2. Route คือ Path ที่ Client เรียกมาหา Kong โดยที่ Route จะต้องผูกกับ Service
(แต่ Service ใด ๆ อาจจะมีมากกว่า 1 route ได้)

3. Consumer คือ คนที่จะเรียกใช้ Service Kong

4. Plugin คือ ตัวที่ทำให้ Kong สามารถทำ Authentication, Rate Limiting หรือ Monitoring Service, ฯลฯ และเราสามารถเขียน Plugin เพิ่มเองได้ด้วย โดยใช้ภาษา Lua ที่เขียนอยู่บน OpenResty ครับ

Port 8000 สำหรับ HTTP Request ที่จะถูกส่งต่อไปยัง Service ตามที่กำหนด และ
Port 8443 สำหรับ HTTPS Request ที่จะถูกส่งต่อไปยัง Service ตามที่กำหนด
Port 8001 สำหรับการตั้งค่า Kong ผ่าน HTTP Request
Port 8444 สำหรับการตั้งค่า Kong ผ่าน HTTPS Request Kong ครับ

และเราสามารถตั้งค่าผ่านทาง Port 8001 หรือ 8444 ด้วยการเรียกใช้ RESTful Administration API โดยตรงได้ แต่เพื่อความสะดวก เราจะตั้งค่าผ่าน Kong Admin GUI ที่ชื่อว่า Konga ผ่าน URL ได้ (จะอธิบายได้ลำดับถัดไป)

ติดตั้ง Docker Engine บน Ruk-Com Cloud PaaS

หลังจากสมัครใช้บริการ Ruk-Com Cloud PaaS เสร็จ ให้สร้าง Environment ซึ่ง Docker Enginge จะรันอยู่บน CentOS

เลือก Docker Engine CE (Docker Community Edition) แบบ Standalone engine สำหรับ Build Container

คลิกเลือก Create a clean standalone engine แล้วกดปุ่ม Install

ระบบกำลัง Deploy Docker Engine CE

เป็นอันสำเร็จการ Deploy ติดตั้ง Docker Engine CE
หลังจากติดตั้ง Docker Engine CE เสร็จแล้ว ให้เปิด Web SSH ดังรูป

วิธีการสร้างระบบ Monitoring ด้วย Grafana และ Prometheus สำหรับ Microservices

เริ่มต้นให้สร้าง Project ขึ้นมาบน Gitlab

การสร้าง Branch บน Gitlab (หรือจะใช้ Github ก็ได้เช่นกัน)

สมัครใช้บริการ Gitlab จากนั้นทำการสร้าง Branch หรือ Initializing Git Branch สร้าง Project ใหม่ชื่อว่า kong-dock

สร้างโปรเจคใหม่ คลิก Crate a project

จากนั้นคลิก Create a project

ถัดมาให้สร้าง Project ใหม่ตั้งชื่อว่า kong-dock

เป็นอันสำเร็จการสร้าง Project

กลับมาที่ Local Host (หรือเซิร์ฟเวอร์) เพื่อสร้าง public SSH key

ssh-keygen -o

cat .ssh/id_rsa.pub

จากนั้นกดปุ่ม Add SSH key แล้วนำ key มาวาง

กลับมาที่ Local Host (หรือบนเซิร์ฟเวอร์) สร้างโฟร์เดอร์ kong-dock โดยใช้คำสั่ง git init

อันนี้เป็น Repository แบบ private ไม่ใช่ public

mkdir kong-dock
cd kong-dock
git init

เชื่อมโยง Local Project กับ Remote Project โดยใช้คำสั่ง git remote

git remote add origin [email protected]:admin948/kong-dock.git

อันนี้เป็น Repository แบบ private นะครับ!

จากนั้นเราสามารถเขียน source code บนเซิร์ฟเวอร์นี้ได้เลย หรือจะทำบน Local (macOS) เมื่อเพิ่ม source code จากนั้น แล้ว Check-In ด้วยคำสั่ง git add และ git commit

Docker Compose คืออะไร?

Docker Compose เป็นเครื่องมือของ docker ที่จะมาช่วยจัดการการสร้าง container หลาย ๆ ตัว ให้เป็นเรื่องที่ง่ายขึ้นมาก ๆ โดยการสร้างไฟล์ที่ชื่อว่า docker-compose.yml ที่เปรียบเสมือนไฟล์ที่ใช้ในการควบคุมการสร้าง container และการกำหนด option ต่าง ๆ ที่ใช้ในการรัน container แต่ละตัวครับ

ในบทความนี้จะใช้ Gitlab สร้าง Project เก็บ Source Code สคริปต์ไฟล์ .yml สำหรับ Build Container โดยเราจะสร้าง Containers เอาไว้ใน Host เดียวกัน (Docker Engine ที่สร้างไว้ก่อนหน้า) ซึ่งประกอบไปด้วย Containers ของ Kong, Postgress, Mongo, Konga, Grafana และ Prometheus ครับ

ไปเริ่มต้นสร้าง Container กันเลย…

เตรียมโครงสร้างโดยให้เราสร้างโฟลเดอร์และไฟล์ดังนี้

เริ่มแรกให้รันคำสั่งอัพเดต pagekage ของโฮสต์ก่อน

yum update

kong-dock
|--------------------- docker-compose.yml
|--------------------- prometheus.yml

สร้าง Project ชื่อ kong-dock ซึ่งภายใน directory จะประกอบด้วยไฟล์ docker-compose.yml และ prometheus.yml

mkdir kong-dock
cd kong-dock

note: สคริปต์ข้างล่งนี้ใช้ Default network ดังนั้น Container ทั้งหมดเชื่อมต่อกันครับ หาก Production ต้องสร้าง Docker Network ให้ Container ก่อนครับ
คำสั่งเรียกดู Networks ทั้งหมดใน Docker
docker network ls

Step 1 — Prepare Nodes Stack

สร้างไฟล์ที่ชื่อว่า docker-compose.yml

ก่อนที่จะได้ Kong container เราต้องสร้าง Dockerfile ขึ้นมาก่อนจากนั้นนำไป build เป็น image และนำไปรันเป็น container เพื่อใช้งาน Kong contaniner ต่อไปครับ

vi docker-compose.yml

services:
  kong-database:
    image: postgres:12-alpine
    container_name: kong-database
    environment:
      - POSTGRES_USER=kong
      - POSTGRES_DB=kong
      - POSTGRES_PASSWORD=kong
    volumes:
      - ./pg_data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 30s
      timeout: 10s
      retries: 5

  migrations:
    depends_on:
      - kong-database
    image: kong
    container_name: kong-migrations
    environment:
      - KONG_DATABASE=postgres
      - KONG_PG_HOST=kong-database
      - KONG_PG_DATABASE=kong
      - KONG_PG_USER=kong
      - KONG_PG_PASSWORD=kong
    command: kong migrations bootstrap -v

  kong:
    depends_on:
      - kong-database
    image: kong
    ports:
      - 80:8000
      - 443:8443 
      - 8001:8001
    container_name: kong
    restart: always
    environment:
      - KONG_DATABASE=postgres
      - KONG_PG_HOST=kong-database
      - KONG_PG_DATABASE=kong
      - KONG_PG_USER=kong
      - KONG_PG_PASSWORD=kong
      - KONG_ADMIN_LISTEN=0.0.0.0:8001
      - KONG_PROXY_LISTEN=0.0.0.0:8000, 0.0.0.0:8443 ssl http2
      - KONG_NGINX_HTTP_RESOLVER=8.8.8.8
      - KONG_PROXY_ERROR_LOG=/dev/stderr
      - KONG_ADMIN_ERROR_LOG=/dev/stderr
      - KONG_TRUSTED_IPS=0.0.0.0/0,::/0
      - KONG_REAL_IP_RECURSIVE=on
    healthcheck:
      test: ["CMD", "wget", "-O-", "http://127.0.0.1:8001/status"]
      interval: 30s
      timeout: 20s
      retries: 5

  mongo:
    image: mongo:4.2.2-bionic
    ports: 
      - 27017:27017
    healthcheck:
      test: echo 'db.stats().ok' | mongo localhost:27017/konga --quiet
      interval: 30s
      timeout: 5s
      retries: 5
    volumes:
      - konga_data:/data/db
  konga:
    image: pantsel/konga:latest
    ports:
      - 1337:1337
    environment:
      DB_ADAPTER: mongo
      DB_DATABASE: konga
      DB_HOST: mongo
      KONGA_SEED_USER_DATA_SOURCE_FILE: /kus.js
      NODE_ENV: production
    volumes:
      - ./kus.js:/kus.js:ro
    restart: on-failure

  prometheus:
    image: prom/prometheus
    ports:
      - 127.0.0.1:9090:9090
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    restart: always

  node_exporter:
    image: prom/node-exporter:latest
    ports:
      - 9100:9100
    container_name: node_exporter
    restart: always
    depends_on:
      - prometheus

  grafana:
    image: grafana/grafana
    ports:
      - 3000:3000
    container_name: grafana
    restart: always
    links: 
      - prometheus:prometheus
    environment:
      GF_INSTALL_PLUGINS: grafana-clock-panel, grafana-simple-json-datasource
    depends_on:
      - prometheus

สร้างไฟล์ชื่อ kus.js เก็บ Username/Password สำหรับ Konga

module.exports = [
    {
        "username": "admin",
        "email": "[email protected]",
        "firstName": "Admin",
        "lastName": "Admin",
        "node_id": "http://kong:8001",
        "admin": true,
        "active": true,
        "password": "admin1234"
    }
];

สร้างไฟล์ที่ชื่อว่า prometheus.yml

vi prometheus.yml

global: 
  external_labels: 
    monitor: devops_monitor
  scrape_interval: 5s
scrape_configs: 
  - job_name: prometheus
    static_configs: 
      - targets: 
        - "localhost:9090"
        
  - job_name: node_exporter
    static_configs:
      - targets:
        - "node_exporter:9100"
        
  - job_name: kong
    static_configs:
      - targets:
        - "kong:8001"

ตัวอย่างคำสั่งคร่าว ๆ ในไฟล์ docker-compose.yml

build
การบอกว่าให้ใช้ image ที่สร้างจาก Dockerfile

context
กำหนด path ที่จะไปเรียก Dockerfile สำหรับสร้าง image

version
เป็นการระบุว่าเราจะใช้ Compose file เวอร์ชั่นไหน

services
เป็นการระบุ container ที่จะต้องใช้

image
เป็นการเรียกใช้ Image จาก Docker Hub Registry

ports
เป็นการทำ port mapping ระหว่าง host กับ container

volumes
คำสั่งที่ใช้ในการกำหนด path ที่ใช้ในการเก็บ folder หรือ file ใดๆที่ถูกสร้างขึ้นโดย docker container (เป็น path ใน container นั้นๆ)

links
เป็นการผูก service เข้าด้วยกัน ทำให้ service สามารถเรียกใช้งาน service ที่ link ได้

restart: alway
เป็นการกำหนดให้ service นั้น restart ตัวเองอัตโนมัติเมื่อเกิดข้อผิดพลาด หรือสั่งให้เริ่มต้นทำงานอัตโนมัติเมื่อเปิดเครื่องขึ้นมาใหม่

network
เป็นการใช้เพื่อสร้างเส้นทางสื่อสารกันระหว่าง container

memory limit
การจำกัดการใช้งาน container เพื่อไม่ให้ใช้ ram เกินที่ตั้งไว้

memory reservations
การกำหนดค่าการใช้งาน ram ขั้นต่ำสำหรับ container

depens_on
คือจะรัน container นี้ได้ก็ต่อเมื่อมี container ชื่อ kong_db และ container นี้จะทำงานทุกครั้งเมื่อเปิดเครื่อง

ดูไฟล์ใน directory kong-dock

kong-dock $ ls -al
total 20
drwxr-xr-x 3 root root 4096 Jan 15 08:45 .
dr-xr-x--- 7 root root 4096 Jan 15 08:03 ..
-rw-r--r-- 1 root root 2532 Jan 15 08:44 docker-compose.yml
drwxr-xr-x 7 root root 4096 Jan 15 08:33 .git
-rw-r--r-- 1 root root  379 Jan 15 08:45 prometheus.yml
-rw-r--r--  1 root     root  813 Jan 15 08:46 kong-start.sh
-rw-r--r--  1 root     root  284 Jan 16 06:30 kus.js

git add .

git commit -m "Initial commit" 
 3 files changed, 174 insertions(+)
 create mode 100644 docker-compose.yml
 create mode 100644 prometheus.yml
 create mode 100644 start.sh

จากนั้นให้ใช้คำสั่ง git log –stat เพื่อดู Commit และดูการเปลี่ยนแปลงของไฟล์

git log --stat --oneline
c24214b Initial commit
 docker-compose.yml | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 prometheus.yml     |  19 +++++++++++++++++
 start.sh           |  44 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 174 insertions(+)

เราสามารถดู Branch บน Local Host โดยใช้คำสั่ง git branch

git branch
* master

เมื่อถึงขั้นตอนนี้ก็ให้ Sync History ของ Master Branch กับ Remote Project โดยใช้คำสั่ง git push

git push -u origin master

The authenticity of host 'gitlab.com (172.65.251.78)' can't be established.
ECDSA key fingerprint is SHA256:HbW3g8zUjNSksFbqTiUWPWg2Bq1x8xdGUrliXFzSnUw.
ECDSA key fingerprint is MD5:f1:d0:fb:46:73:7a:70:92:5a:ab:5d:ef:43:e2:1c:35.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'gitlab.com,172.65.251.78' (ECDSA) to the list of known hosts.
Counting objects: 5, done.
Delta compression using up to 6 threads.
Compressing objects: 100% (5/5), done.
Writing objects: 100% (5/5), 1.57 KiB | 0 bytes/s, done.
Total 5 (delta 0), reused 0 (delta 0)
To [email protected]:admin948/kong-dock.git
 * [new branch]      master -> master
Branch master set up to track remote branch master from origin.

ดู Git Project บน Gitlab

กรณีที่เราต้องการโคลน source code ผ่าน SSH ลงมาที่เครื่อง Local อื่น ๆ เช่น macOS หรือ Linux desktop ให้ใช้คำสั่ง git clone <URL> เช่น git clone [email protected]:admin948/kong-dock.git

Step 2 — Deploy Containers

รันคำสั่ง Build container จากไฟล์สคริปต์ docker-compose.yml

docker-compose up -d

d= option ที่ใช้กำหนดว่า ให้รันแบบ background process

โดยบทความนี้เราจะรันคำสั่ง Build container สำหรับ Project “kong-dock”
ด้วยสคริปต์ Build container สร้างไฟล์ใหม่ชื่อ kong-start.sh

สคริปต์: clean up / old running instance, re-build, และ start Kong

#!/bin/bash

echo "Starting kong-database..."

docker-compose up -d kong-database

STATUS="starting"

while [ "$STATUS" != "healthy" ]
do
    STATUS=$(docker inspect --format {{.State.Health.Status}} kong-database)
    echo "kong-database state = $STATUS"
    sleep 5
done

echo "Run database migrations..."

docker-compose up migrations

echo "Starting kong..."

docker-compose up -d kong

echo "Kong admin running http://0.0.0.0:8001/"
echo "Kong proxy running http://0.0.0.0/"

echo "Starting konga..."

docker-compose up -d mongo konga

echo "Konga running http://0.0.0.0:1337/"

echo "Starting grafana..."

docker-compose up -d grafana

echo "Grafana running http://0.0.0.0:3000/"

echo "Starting prometheus..."

docker-compose up -d prometheus node_exporter

echo "Prometheus running http://0.0.0.0:9090/"

docker-compose up -d

Step 3 — Starting Nodes

หรือจะรันด้วยสคริปต์ก็ได้เช่นกันครับ

sh kong-start.sh

รันคำสั่งดู images ทั้งหมดที่โหลดมาแล้ว

docker images

Step 4 — Check if Kong Nodes are running

รันคำสั่งดู Containers ที่รันอยู่

docker-compose ps

# HTTP
curl -i http://localhost:8001/

# HTTPS
curl -i --insecure https://localhost:8444/

ถัดไปเราจะมาคอนฟิก Kong ผ่าน Konga เพื่อสร้าง Connection กัน

สร้าง Connection เพื่อไปต่อกับ Kong

ล็อกอินเข้าสู่หน้า Konga Kong Admin <IP Address>:1337 จากนั้นกำหนดค่านั้นนี้

Name ตั้งชื่ออะไรก็ได้ (สมมุติว่า kong)
Kong Admin URL ให้ใส่ http://kong:8001/
เราสามารถเรียกด้วยชื่อ service ได้เลยเพราะ kong รันอยู่ใน docker-compose

หน้า Admin GUI

สร้าง Register Gateway

สร้าง Service โดยกดที่เมนู SERVICES แล้วกด + ADD NEW SERVICE

Path ระบุเป็น UPSTREAM เซิร์ฟเวอร์อารมณ์เดียวกับ NGINX นั้นแหละครับ เช่น ชี้ Path ไปที่ Microservices ที่รันระบบลงทะเบียน (/register) เป็นต้น
ดังนั้น Kong จึงเป็นหน้าด่านรับ Request และกระจายงานและประสานงานกับ Service ต่าง ๆ

credit image: https://martinfowler.com/articles/microservices.html

ใส่ชื่อ Service, Protocol, Host (Private IP Address ของเซิร์ฟเวอร์), Port และ Path แล้วกด SUBMIT SERVICE

สร้าง Routes ให้ Register Gateway

สร้าง Route โดยกดที่ RegisterGateway แล้วกดที่แถบ Routes

กด + ADD ROUTE ใส่ชื่อ Route Name ใส่ข้อมูล Paths, Methods และ Protocols โดยกด Enter ทุกครั้ง แล้วกด SUBMIT ROUTE

Authentication

Authentication เป็นการยืนยันตัวตนเมื่อเข้าใช้งาน เราจะตั้งค่า Kong ให้ทำ Authentication แบบ Basic Authen และ API Key กับ Request ที่เข้ามาจากภายนอก ก่อนส่งต่อไปหา Register Gateway Service โดยมีขั้นตอนดังนี้

สร้าง Consumer โดยกดเมนู CONSUMERS กด CREATE CONSUMER ใส่ username เป็น (สมุมติใช้ว่า suseman) กด SUBMIT CONSUMER แล้วกด Tab Credentials

สร้าง Kong Consumer

ไปที่เมนู CONSUMERS และสร้าง Consumer กดปุ่ม + CREATE CONSUMER

ถัดมาเลือกเมนู BASIC กด + CREATE CREDENTIALS ใส่ข้อมูล username และ password แล้วกด SUBMIT

เลือกเมนู API KEYS กด + CREATE API KEY ปล่อย key เป็นค่าว่างไว้ เพื่อให้ Kong สร้าง key ที่ปลอดภัยให้โดยอัตโนมัติ แล้วกด SUBMIT

ถัดมาให้เราทำ Authen กับ ROUTE โดยการกดที่เมนู ROUTES กด registerRoute แล้วเลือก Plugins

กด + ADD PLUGIN เลือก Basic Auth ปล่อย consumer ไว้ Kong จะเลือกจาก consumer ที่เราตั้งไว้ แล้วกด ADD PLUGIN อีกครั้ง

ปล่อย consumer ไว้ Kong จะเลือกจาก consumer ที่เราตั้งไว้ แล้วกด ADD PLUGIN อีกครั้ง

จากนั้นกดเพิ่ม PLUGIN อีกอันเลือก Key Auth ปล่อย consumer ไว้ ใส่ key names กด Enter แล้วกด ADD PLUGIN

หลังจากเสร็จแล้วให้ทำการ Disabled key-auth เพื่อทดลองกดส่ง Request ใน Postman ไปยัง http://<IP Address>/register เพื่อให้ Kong ทำ Authen แบบ basic-auth

จากนั้น Enabled key-auth และ Disabled basic-auth เพื่อทดลองกดส่ง Request ใน Postman ครับ

สร้าง Rate Limiting ควบคุม Traffic

Kong เราสามารถทำการกำหนดควบคุม Traffic ได้ว่าเช่น
ใน 1 วินาที/นาที/ชั่วโมง/วัน จะมี Request ได้กี่ครั้ง ด้วยการทำ Rate Limiting จาก Plugin โดยมีขั้นตอนดังนี้

ทำ Rate Limiting กับ ROUTE โดยการกดที่เมนู ROUTES กด registerRoute แล้วเลือก Plugins
กด ADD PLUGIN เลือกเมนู Traffic Control กด ADD PLUGIN ที่ Rate Limiting กำหนดให้ส่ง Request ได้ 5,000 ครั้ง ต่อชั่วโมง แล้วกด ADD PLUGIN

จากนั้นทดลองกดส่ง Request ใน Postman จะเห็นว่า X-RateLimit-Remaining-Hour เหลือ 4999 และเมื่อกดส่งอีกครั้ง X-RateLimit-Remaining-Hour จะเหลือ 4998

Prometheus + Grafana

ถัดมาเราจะใช้ Prometheus ในการจัดเก็บข้อมูลต่าง ๆ ของ Docker Engine เซิร์ฟเวอร์และ Service ในแบบ Time Series และใช้ Grafana สำหรับดึงข้อมูลมาแสดงบน Real-Time Dashboard

ก่อนอื่นเราจะต้องทำการ Add plugin ใน Kong เพื่อ Monitor Consumer แล้วติดตั้ง Grafana Container ตามขั้นตอนดังต่อไปนี้

เลือกเมนู CONSUMERS กดที่ suseman แล้วเลือกแท็ป Plugins

กด + ADD NEW PLUGIN

เลือกเมนู Analytics & Monitoring กด ADD PLUGIN ที่ Prometheus
แล้วกด ADD PLUGIN อีกครั้ง

จากนั้นทดสอบล็อกอิน Grafana ที่ <IP Address>:3000
โดยดีฟอลต์ Username/Password คือ admin/admin และระบบจะขึ้นให้เปลี่ยน Password ใหม่

เชื่อมต่อ Grafana เข้ากับ Prometheus

กด Add data source เลือก Prometheus

ใส่ URL http://prometheus:9090 เพื่อ Connect ไปยัง Prometheus Container แล้วกด Save & Test (เราก็ใส่เป็นชื่อ Container เรียกแทนได้เลยในที่นี้คือ prometheus ครับ)

เลือกเมนู + Create เพื่อ Import Dashboard

ใส่ ID ของ Dashboard ที่เราจะติดตั้ง เลือก Prometheus Data Source เป็น Prometheus แล้วกด Import

ติดตั้งปลั๊กอิน redis-datasource

หรือทดลองติดตั้ง Redis Datasource คลิกดูวิธีติดตั้ง Grafana Redis Datasource

เข้าสู่ Grafana container ด้วยคำสั่ง docker exec -it <ชื่อ container> ตามด้วยคำสั่ง

docker exec -it grafana bash

grafana-cli plugins install redis-datasource

คลิกดูวิธีติดตั้ง Grafana Redis Datasource

เราสามารถค้นหา Dashboard อื่น ๆ ได้จากที่นี้ https://grafana.com/grafana/dashboards
สำหรับ Dashboard ID ของ Kong APIs Monitoring แบบ Official คือ 7424 ครับ

คำสั่ง Stop/Delete Container และ Delete Image ด้วย Docker-compose คือ

docker-compose down --rmi all

สุดท้ายขอขอบคุณแหล่งที่มาต่าง ๆ นี้ด้วยนะครับ
https://docs.docker.com/engine/reference/commandline/docker/
https://medium.com/swlh/creating-and-installing-custom-lua-plugins-in-kong-ce7fd64d33bf
https://grafana.com/grafana/dashboards/893
https://blog.pjjop.org/build-api-gateway-and-monitoring-microservice-with-kong-prometheus-and-grafana/
https://i.dont.works/kong-api-gateway-in-10-minute/
https://medium.com/devopsturkiye/kong-api-gateway-installing-configuring-and-securing-dfea423ee53c

สำหรับบทความนี้ก็คงประมาณนี้ ผู้ที่สนใน Dockerfile และ Docker Compose สามารถศึกษาเพิ่มเติมได้จาก Dockerfile หรือ Docker Compose ได้เลยครับ ตามลิงก์ข้างล่างนี้เลย
https://docs.docker.com/engine/reference/builder/
https://docs.docker.com/compose/compose-file/
https://docs.docker.com/develop/develop-images/dockerfile_best-practices/

และต้องขอขอบคุณ Ruk-Com Cloud PaaS ที่ให้การสนับสนุน Environment สร้าง Docker Engine CE ครับผม ^^

เราทุกคนกำลังอยู่ในยุคที่ท้าทายมากที่สุดยุคหนึ่งในประวัติศาตร์ เราไม่มีทางรู้เลยว่าจะเกิดอะไรขึ้นอีกบ้างในอนาคตครับ ไม่ต้องคิดไปไกลถึงรุ่นลูก… เอาแค่อีก 3-5 ปีข้างหน้า เรายังคาดเดาลำบากเลย จริงไหมครับ

เพราะชีวิตการทำงานในยุคนี้ไม่ใช่เรื่องง่าย ไม่ใช่แค่เด็กจบใหม่เท่านั้นที่รู้เรื่อง Cloud แม้แต่คนที่ทำงานมานานแล้วหลายปีที่ไม่ Reskill ก็อาจพบว่าโลกของการทำงานในยุคนี้ “อยู่ยากกว่าที่เคย” ตามเด็กจบใหม่ไม่ทัน…

“การปรับตัว” เพื่อ Reskill / Upskill พัฒนาทักษะของตัวเองให้มากขึ้น จึงเป็นเรื่องที่ควรทำครับ เพื่อก้าวสู่การเป็น “คนทำงานคุณภาพ” ในยุค Cloud

โปรด Order อีบุ๊คบันทึกลับนี้อ่านเพราะไม่มีงานมันน่ากลัว” เผยเคล็ดลับปรับตัวเป็นคนทำงานคุณภาพในยุค พร้อมเทคนิคการประสบการณ์ทำงานจริงๆ และปรับใช้ได้กับองค์กรขอบคุณครับ

Cloud web hosting / Google data studio ไม่ใช่เรื่องยากอีกต่อไป…เนื้อหาสุดเข้มข้น แม้ไม่มีพื้นฐานก็เรียนรู้ทำตามได้ เพราะคำว่า “ทักษะ” นั่นสามารถพัฒนากันได้ครับ
สั่งซื้อออนไลน์ ได้เลยที่นี่: https://www.suseman.com/shop/ebooks/