Forem: terngr

API Security with encrypted value in endpoints

terngr — Fri, 28 Nov 2025 19:08:26 +0000

งานนี้จะแชร์การใช้งาน Generative AI มาทำงานแทนเรา ในงานที่เราทำเป็นอยู่แล้ว แต่อยากลดเวลา และเราสามารถตรวจงานได้ง่ายครับ โดยรวมคือใช้เวลาเพียง 5-10 นาที แทนที่จะใช้ 30-60 นาที ทำให้มีเวลาไปดูพระอาทิตย์ตกทันนั่นเอง
.
โจทย์คือ API Security จุดซึ่งมีการทำ End to end encryption ตัว Value ใน Key: Value เช่นยอดเงินในบัญชีธนาคาร
.
การจะทำ Security ให้กับ API ได้ โดยปกติก็จะต้องมี API ใช้งานก่อน หรือก็คือมีข้อมูล API มาให้ปกป้องนั่นเอง ฉะนั้นเราจะสร้าง API Application ขึ้นมา 1 ตัว โดยมีความสามารถในการ Encrypted ยอดเงินในบัญชีได้ด้วย ฉะนั้้นเมื่อปลายทางอ่านข้อมูลนี้ไปได้ แบบ End to end ก็จะได้ Encrypted value ซึ่งจะต้องนำไป decrypt ด้วย key เดียวกัน จึงจะได้ยอดเงินจริงออกมาใช้งานได้นั่นเอง
.
โดยปกติแล้ว เราสามารถสร้าง Rest API ด้วย Python ได้เลย และเรียกใช้ .encrypt function เพื่อทำการ encrypt ข้อมูลที่ต้องการ แต่วันนี้เราจะลองใช้ Generative Model มาช่วยเขียน

ผลที่ได้ในแต่ละ Step อาจมีความต่างกันบ้าง เช่น Logic ที่ไม่ถูก อันนี้ต้องดูแล้วปรับเฉพาะจุด

และความต่างเรื่องการตั้งชื่อตัวแปร ว่าสอดคล้องกับความหมายมากน้อยแค่ไหน

อันนี้เป็นผลลัพธ์ที่ได้ เมื่อเรียกไปที่ /customer/1

จะพบว่า Account_number และ balance ถูก Encrypted เรียบร้อยแล้ว

สามารถปรับแต่งให้บางจุด เกิดความไม่ปลอดภัย เพื่อทดสอบการทำ API Security ได้ด้วย
เช่นที่ /customer/3 จะไม่ถูก encrypted

จะพบว่า Account_number และ balance ไม่ได้ถูก Encrypted ไว้

โดยเบื้องหลัง จะมี Function สำหรับ Encrypt
การใช้งานจริงจำเป็นต้องปรับเปลี่ยนวิธีการเก็บ Encryption key ให้ปลอดภัย

# === MOCK AES KEY (32 bytes = AES-256) ===
AES_KEY = b"this_is_a_32_byte_secret_key!!"

def encrypt_aes(data: str) -> str:
    cipher = AES.new(AES_KEY, AES.MODE_GCM)
    ciphertext, tag = cipher.encrypt_and_digest(data.encode())

    encrypted_payload = {
        "nonce": base64.b64encode(cipher.nonce).decode(),
        "ciphertext": base64.b64encode(ciphertext).decode(),
        "tag": base64.b64encode(tag).decode()
    }

    return base64.b64encode(json.dumps(encrypted_payload).encode()).decode()

โดยใน Function จะมีการเรียก .encrypt_and_digest และ .b64encode ตามลำดับ

หลังจากเพิ่ม endpoint เขาไป 5-6 ตัว จะได้ไฟล์ล่าสุด main.py

from fastapi import FastAPI
from Crypto.Cipher import AES
import base64
import json

app = FastAPI()

# === MOCK AES KEY (32 bytes = AES-256) ===
AES_KEY = b"this_is_a_32_byte_secret_key!!"

def encrypt_aes(data: str) -> str:
    cipher = AES.new(AES_KEY, AES.MODE_GCM)
    ciphertext, tag = cipher.encrypt_and_digest(data.encode())

    encrypted_payload = {
        "nonce": base64.b64encode(cipher.nonce).decode(),
        "ciphertext": base64.b64encode(ciphertext).decode(),
        "tag": base64.b64encode(tag).decode()
    }

    return base64.b64encode(json.dumps(encrypted_payload).encode()).decode()


# =========================
# Customer Endpoints
# =========================

@app.get("/customer/1")
def get_customer_1():
    return {
        "customer_id": 1,
        "full_name": "John Smith",
        "bank_name": "Mock National Bank",
        "account_type": "Savings",
        "account_number_encrypted": encrypt_aes("123-4-56789-0"),
        "balance_encrypted": encrypt_aes("125430.75"),
        "currency": "USD",
        "status": "Active",
        "encryption": "AES-256-GCM"
    }


@app.get("/customer/2")
def get_customer_2():
    return {
        "customer_id": 2,
        "full_name": "Emma Johnson",
        "bank_name": "Mock National Bank",
        "account_type": "Checking",
        "account_number_encrypted": encrypt_aes("987-6-54321-9"),
        "balance_encrypted": encrypt_aes("98750.25"),
        "currency": "USD",
        "status": "Active",
        "encryption": "AES-256-GCM"
    }


# =========================
# Branch Endpoint (NO Encryption)
# =========================

@app.get("/branch")
def get_branches():
    return {
        "bank_name": "Mock National Bank",
        "total_branches": 3,
        "branches": [
            {
                "branch_id": 1,
                "branch_name": "Bangkok Main Branch",
                "address": "123 Silom Road, Bangkok, Thailand",
                "phone": "+66-2-123-4567",
                "status": "Open"
            },
            {
                "branch_id": 2,
                "branch_name": "Chiang Mai Branch",
                "address": "88 Nimmanhaemin Road, Chiang Mai, Thailand",
                "phone": "+66-53-987-654",
                "status": "Open"
            },
            {
                "branch_id": 3,
                "branch_name": "Phuket Branch",
                "address": "55 Patong Beach Road, Phuket, Thailand",
                "phone": "+66-76-111-222",
                "status": "Closed"
            }
        ]
    }


# =========================
# Finance Endpoint (ALL Encrypted)
# =========================

@app.get("/finance")
def get_finance_summary():
    return {
        "bank_name": "Mock National Bank",
        "report_type": "Branch Deposit Summary",
        "currency": "USD",
        "encryption": "AES-256-GCM",
        "branches": [
            {
                "branch_id": 1,
                "branch_name": "Bangkok Main Branch",
                "total_deposit_encrypted": encrypt_aes("12500000.50")
            },
            {
                "branch_id": 2,
                "branch_name": "Chiang Mai Branch",
                "total_deposit_encrypted": encrypt_aes("5420000.75")
            },
            {
                "branch_id": 3,
                "branch_name": "Phuket Branch",
                "total_deposit_encrypted": encrypt_aes("3189000.00")
            }
        ]
    }

จากนั้นทำการสร้าง docker compose, พร้อม Dockerfile และสร้าง tunnel published ขึ้น https

สรุปต้นแบบใช้เวลาประมาณ 5 นาที รวมปรับเพิ่ม Endpoints ไม่เกิน 10 นาที ก็ได้ Apps ไว้ทดสอบ API Security 1 ตัว เทียบกับต้องเขียนเองหมด ต้องหาชื่อ library ที่จะใช้ อย่างเร็วก็น่าจะครึ่งชั่วโมง ถือว่าประหยัดเวลาได้ประมาณ 6 เท่านั่นเอง

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

NGINX API Authentication/Authorization

terngr — Tue, 21 Oct 2025 04:42:51 +0000

From the top image: เป็นเครื่องมือวัดอุณหภูมิที่ ノーヴァ新横浜 สกีรีสอร์ทในร่มที่ Shinyokohama เมื่อสัปดาห์ที่แล้วครับ (ต้นเดือนตุลาคม 2025)
ไว้ดับร้อนเรื่องร้อนๆ ถ้านำ NGINX ไปช่วยทำ API Management, API Security, รวมถึง Authentication จากร้อนๆ ก็จะเย็นสบายเลยครับ ขนาดใส่เสื้อกันหนาวแล้วยังเย็นอยู่เลย

NGINX ทั้ง Open Source และ Plus สามารถทำ Authentication/Authorization ได้

ในตัวอย่าง จะมีตั้ง Service ชื่อ cat-api ขึ้นมา เพื่อให้บริการ api แบบ unauthenticated

จะเห็นได้ว่า เราสามารถเรียกใช้บริการ ถามชื่อแมว ได้ผ่าน /cat ก็จะได้ชื่อแมว โดยไม่ต้อง Authenticate

เรารัน NGINX ขึ้นมา เพื่อทำหน้าที่ Authentication (ในทางปฏิบัติ สามารถใช้ MAP เพื่อทำ authorization หรือทำ RBAC ได้ด้วย)

จะเห็นได้ว่า ตอนนี้ถ้าเรียกใช้งานผ่าน NGINX จำเป็นต้อง Provide valid API key เสียก่อน จึงจะใช้บริการ ถามชื่อแมว ได้

สิ่งที่ต้องทำต่อ ก็คือจำกัดการเข้าใช้บริการ cat-api โดยตรง โดยเราจะ bind port เฉพาะ NGINX ที่ทำหน้าที่ Authentication/Authorization เท่านั้น แล้วให้ NGINX เรียกผ่าน network: f1-net ไปยัง cat-api อีกต่อหนึ่ง

สิ่งที่ได้ ก็จะทำ Authentication ให้กับ cat-api ได้นั่นเองครับ

ทั้งนี้ NGINX ยังสามารถใช้ map directive ช่วยทำ Authorization และ RBAC ได้ด้วย,
สำหรับ NGINX Plus จะมีรองรับ JWT, รวมถึง OIDC, SAML ก็รองรับ และเร็วๆ นี้ยังมี Module เฉพาะสำหรับ LDAP ด้วย ทำให้ NGINX คุยกับ LDAP ได้โดยตรงครับ (เดิมต้องผ่าน 3rd party)

NGINX - Native support ACME Protocol

terngr — Tue, 23 Sep 2025 19:10:55 +0000

NGINX ออก Preview Release ของตัว ACME แบบ Native พร้อมใช้แล้ววันนี้ สำหรับ NGINX Plus R35 (Based on NGINX OSS 1.29.0) และ NGINX OSS 1.29.1
เนื่องจากเป็น Preview Release ยังรองรับเฉพาะ HTTP-01 challenges

Automated Certificate Management Environment　(ACME) เป็นโปรโตคอลที่ใช้คุยกับ Certificate Authority (CA) หรือบางท่านเรียนคนออก Certificate ที่มาช่วยบอกว่าเว็บไซต์ของเราเป็นเว็บแท้แน่นอน โดย ACME ช่วย Automate กระบวนการ ตั้งแต่ Issuing, Validating, Renewing, Revoking ครบวงจร

โดยปกติถ้าเรา Configure HTTPS บน NGINX ก็จะต้องใส่ Certificate ด้วย ซึ่งการได้มาซึ่ง Certificate นี้ เราอาจทำเอง หรือใช้เครื่องมือ (เช่น Certbot) ช่วยก็ได้
ตอนนี้ NGINX ได้นำความสามารถนี้มารวมใน NGINX แล้ว ฉะนั้น NGINX ตั้งแต่ NGINX Plus R35 และ NGINX OSS 1.29.1 จะสามารถที่จะขอ Issuing และ Renewing Certificates ได้เอง

NGINX ใช้ Rust SDK มาช่วย โดยแยกเป็น Module ชื่อ nginx-plus-module-acme และ nginx-module-acme สำหรับ NGINX Plus และ NGINX OSS ตามลำดับ

การใช้งาน หลังจากติดตั้ง NGINX Plus ตามขั้นตอนปกติ ให้รันติดตั้ง nginx-plus-module-acme ด้วย เช่น
sudo apt install nginx-plus-module-acme

สำหรับ NGINX OSS ให้ติดตั้งเป็น
sudo apt install nginx-module-acme

ซึ่งเป็นขั้นตอนติดตั้ง Module Package ตามปกติของ NGINX Plus / NGINX OSS
ทั้งนี้ เราจำเป็นต้องเลือกเวอร์ชั่นของ Module ให้ตรงกับเวอร์ชั่นของ NGINX ด้วย ฉะนั้นในวันนี้เนื่องจาก Module เพิ่งออก จึงไม่ค่อยมีปัญหา(แต่มี Diff Version บ้าง) แต่หากนานไปแล้วเวอร์ชั่นห่างกัน ตอนใช้งานก็จำเป็นต้องเช็คความเข้ากันได้ (คือต้อง Version เดียวกัน) นั่นเอง

หลังจากนั้นให้โหลด Module เข้าใช้งาน โดยเขียน Configuration ที่ชั้นนอกสุดของ Configuration หรือวางไว้บรรทัดแรกของ /etc/nginx/nginx.conf จะง่ายต่อการทำงานเพราะจะเห็นง่ายว่ากำลังใช้ Module อะไรบ้าง

Recap การขอ Certificate

ก่อนใช้งาน ขอ Recap การขอ Certificate ว่าเราต้องมีสิทธิ์ใน FQDN และ Resolve name ไปที่ IP ที่กำหนด การทำ Challenge แบบ HTTP-01 challenges นั้น CA จะส่ง Challenge　มายัง IP เพื่อดูว่าได้รับจริงไหม

Challenge ที่ได้

เมื่อ Challenge สำเร็จ ก็จะออก Certificate ให้ พร้อมนำมาวางให้ใน NGINX

NGIXN มี Future Plan จะมี Challenges แบบอื่นๆ มาเพิ่มครับ: เช่น ALPN, DNS-01

NGINX Configuration

หลังจากเราโหลดโมดูลแล้ว ให้ Configure ดังนี้ ภายใต้ http {} block

ตั้ง Resolver (บังคับตั้ง) เพื่อให้ Resolve Name ไปยัง Certificate Authority ได้
resolver 8.8.8.8;

ใส่รายละเอียดของ ACME Issuer ที่จะใช้งาน, path ที่จะเก็บ Certificate ที่ขอได้ เพื่อนำไปใช้ต่อ

ในตัวอย่าง ใช้ Letsencrypt ซึ่งมี directory ในการขออยู่ที่

https://acme-v02.api.letsencrypt.org/directory

และจะเก็บ เรียกใช้ Certificates ที่

ตั้ง acme_shared_zone
acme_shared_zone zone=acme_shared:1M;

ย้อนไปนิดหนึ่ง ตอนส่ง Challenge มา เราต้องเปิด HTTP port 80 รอรับ เพื่อเช็คว่าได้รับข้อความจริงไหม เป็นเจ้าของตัวจริงไหม โดยเปิดรับ port 80 เสมอ เพื่อทำ Challenge (ในอนาคตอาจมีท่าอื่นเพิ่ม)

เมื่อ Challenge สำเร็จ จะนำ Certificate ไปใช้โดยอ้างตัวแปรชื่อ $acme_certificate สำหรับ ssl_certificate และ $acme_certificate_key สำหรับ ssl_certificate_key ตามลำดับ

ยังสามารถดูไฟล์ Certificates จริงได้ด้วย จะเป็น Key pairs ของ Certificate กับ Key นั่นเอง

ตรวจสอบ Configuration และ Restart NGINX ถ้าไม่ได้เกิดปัญหา Error log จะไม่เห็นอะไร แต่จะเห็นการขอ Challenge มาใน Access log

หากเกิด Error ให้แก้ไข เช่น Resolve name ติดต่อ CA ไม่ได้ ให้เปลี่ยนที่อยู่ resolver
หรือถ้าทดสอบลบเพื่อขอ Issue ใหม่ ขอเร็วและถี่เกินไปก็จะถูกปฏิเสธไม่ให้ขอได้

เมื่อเรียบร้อยแล้ว ทดลองเข้าหน้าเว็บด้วย FQDN แบบ https

Connection is secure
Certificate is valid

ระบุว่า Issued By Let's Encrypt

สรุป

NGINX ได้ทำ ACME ได้แบบ Native แล้วโดยยังรองรับได้แค่บาง Features ของ Review release

NGINX ยังมีอีกหลาย โมดูล ที่จะมาช่วยเพิ่มประสิทธิภาพงาน

Lost Recovery Keys with Auto Unseal – Vault

terngr — Fri, 19 Sep 2025 23:05:24 +0000

เป็นหนึ่งจากหลายๆ เคสที่ถูก Raise มาถึงเราในสัปดาห์นี้ และน่าจะเป็นเคสที่สนุกสุดด้วยเพราะผู้เขียนยอมอดกินเนื้อย่างคืนวันศุกร์เพื่อมาแก้เคสนี้ ＃เคสที่ดีมักจะมาเย็นวันศุกร์ ตอนที่กำลังจะกลับบ้าน

ด้วยตัว HashiCorp Vault ทางทฤษฏี เคสนี้ควรจะถูกแก้ได้ แต่พอไปดูเครื่องมืออาจจะยังไม่ครอบคลุม (หรือจะมองอีกมุม ว่าเพื่อความปลอดภัยและความชัดเจนในมุมการใช้งานของ Product เองก็ได้ครับ) ในที่นี้ wrapped key ที่ต้องการมีพร้อม ขาดแค่เครื่องมือ ซึ่งเราสร้างเพิ่มขึ้นมา

Introduction

Vault provides centralized, well-audited privileged access and secret management for mission-critical data whether you deploy systems on-premises, in the cloud, or in a hybrid environment.
With a modular design based around a growing plugin ecosystem, Vault lets you integrate with your existing systems and customize your application workflow.

Vault เป็นเครื่องมือช่วยบริหารจัดการ Secrets โดยปกติจะมี 2 Modes

Unseal: พร้อมใช้งาน จัดการ Secrets ได้ เรียกขอ Secrets ไปใช้งานก็ได้
Seal: ไม่พร้อมใช้งาน ต้อง Unseal ก่อน, ถ้ามี Incident เกิดขึ้นเราสามารถสั่ง Seal Vault ได้ทันที เพื่อหยุดยั้งการเข้าถึง Secrets

โดยปกติการ Unseal จะใช้ผู้ถือ Key หลายๆ คน เช่น 5 ท่าน แล้วตั้งข้อกำหนดขั้นต่ำ (ที่เกินกึ่งหนึ่ง) เช่นต้องใช้ 3 ท่าน เพื่อจะทำการ Unseal เพื่อให้ Vault พร้อมใช้งาน ซึ่งกระบวนการนี้ หากต้อง Seal/Unseal บ่อยๆ ก็จะไม่สะดวก

การ Seal/Unseal โดยใช้ Shamir portions

อีกทางเลือกหนึ่ง เราสามารถใช้ Auto Unseal โดยให้หน้าที่ในการปกป้อง Unseal Key ตกไปอยู่ที่ Trusted device / service เช่น AWS Key Management Service (AWS KMS)

การทำ Auto unseal

ทั้งนี้ การใช้ Auto unseal จะมีการสร้าง Recovery key ในทำนองเดียวกับการสร้าง Unseal key (แต่ไม่ได้ใช้เพื่อ Unseal) เพื่อให้ครอบคลุมการทำงานบางอย่างนอกเหนือการทำ Auto unseal เช่นการสร้าง root token, rekey

ฉะนั้น เมื่อเราใช้ Auto unseal แล้วต้องการสร้าง Root token ใหม่ ก็จะต้องมี Recovery key ตามจำนวนที่กำหนด เช่น 3 ท่าน จาก 5 ท่าน

Problem

ในระบบ มีการรัน Vault แบบ Auto unseal ไว้แล้ว เช่นใช้ AWS KMS ช่วย
ฉะนั้นสถานะปัจจุบัน จึงเป็น unseal (Sealed = false) หรือพร้อมใช้งานนั่นเอง

แต่ Recovery key หายไป ทำให้ไม่สามารถสร้าง root token ใหม่ และ ไม่สามารถ Save/Restore snapshot

เมื่อพยายามสร้าง root token ใหม่ จะถามหา Recovery key portions ซึ่งติดปัญหาสูญหาย/มีไม่ครบ

เราตรวจสอบได้ว่าตอนนี้เป็น unseal mode ปกติ (ใช้ Unseal key) หรือเป็น Auto unseal (ใช้ Recovery key) โดยดูจากรูป vault status แสดง Recovery Seal Type ก็คือเป็น Auto unseal นั่นเอง

Investigation

หลักของการทำ Shamir's secret sharing (SSS) เริ่มจากเรามี　Secret ที่ต้องการปกป้องกันก่อน
ในที่นี้ก็คือ มี Recovery key แล้วจึงสร้าง Recovery key portion ตามมา เพื่อที่ตอนใช้งานเราจะนำแต่ละ Recovery key portion ทั้งหมดหรือบางส่วน มาประกอบเป็น Recovery key เพื่อได้รับ Authorization จาก Vault operator ให้สร้าง Root token, rekey, etc ได้นั่นเอง ทั้งนี้ Recovery key จะยังใช้ Unseal ไม่ได้(เพราะการ Unseal ต้องใช้ Trusted device /service เช่น AWS KMS โดยท่าที่แนะนำคือเรานำเข้าคีย์เอง เพื่อให้มีสำรองไว้กรณี service ใช้งานไม่ได้ ก็จะนำเข้าคีย์เดิมเข้าไปใหม่ได้)

จากข้อมูลใน Vault's Document จำเป็นต้องใช้ Recovery key portion และเราทราบว่าสามารถสร้าง Recovery key portion ได้ใหม่จาก Recovery key โดย Recovery key portion ที่สร้างใหม่นี้ อาจไม่ซ้ำกันในแต่ละครั้งก็ได้ แต่เมื่อรวม portion ในจำนวนที่กำหนดแล้วจะได้ Recovery key ฉะนั้นเราต้องหา Recovery key, เช็ค Storage Path ได้จาก Configuration file และเช็คไฟล์ข้างใน พบ _recovery-key

ก่อนหน้าที่เราจะเช็คไฟล์ มีการตรวจสิทธิ์ของ aws_kms_key ที่ใช้ พบว่าสามารถทำ Encryption, Decryption, DescribeKey ได้ ซึ่งสิทธิ์พวกนี้เพียงพอต่อการทำ Auto unseal แต่จะถูกใช้กับ Recovery key ด้วยไหม

เรายังรู้อีกว่า HashiCorp มี go library ที่สามารถ Wrap (Encrypt/Decrypt secret) ด้วย aws_kms_key ได้

ซึ่งการเรียกใช้ wrapper.Decrypt นี้ ต้องมี AWSKMS_WRAPPER_KEY_ID ซึ่งเรามีอยู่แล้ว จะอยู่ใน vault configuration file เป็นคีย์ที่ใช้ทำ Auto unseal นั่นเอง

ส่วนสิ่งที่เราจะ Decrypt ก็คือไฟล์ที่อยู่ใน storage นั่นเอง

/opt/vault/core/_recovery-key

จากไฟล์ _recovery-key เราใช้ jq ดึงเฉพาะ .Value และ Encode ด้วย Base64

sudo cat /opt/vault/core/_recovery-key | jq -r .Value | base64 -d > key.enc

จากนั้น go run โดยใส่ parameter ค่าที่ได้จาก _recovery-key, ระบุจำนวน shares และ threshold เพื่อใช้ในการสร้าง portions ของ SSS โดยแต่ละครั้งอาจได้ SSS portion ต่างกัน และยังต้องระบุ AWSKMS_WRAPPER_KEY_ID เพื่อใช้ decrypt

go run main.go -enc-key key.enc -env awskms -shamir-shares 5 -shamir-threshold 3

ตอนนี้เราก็สามารถเรียกใช้ vault operator ที่ต้องใช้ Recovery key portion ได้แล้ว

ทำการ Rekey

vault operator rekey \
-target=recovery \
-init \
-key-shares=5 \
-key-threshold=3

ทั้งนี้ หากใช้ Recovery Key portion ชุดใหม่ แต่มาจากการทำ SSS ต่างชุดกัน จะใช้รวมกันสร้าง Recovery Key ไม่ได้

เราลองมาสร้าง root token ใหม่ แต่ใช้ Recovery Key portion ชุดเก่า (ก่อน rekey)

sukkarin@ubuntu:~$ vault operator generate-root -init
A One-Time-Password has been generated for you and is shown in the OTP field.
You will need this value to decode the resulting root token, so keep it safe.
Nonce         7d60070e-32c3-a3c0-eaa8-758992802f1a
Started       true
Progress      0/3
Complete      false
OTP           oS2IqxJ06xhPrv5yms6WP7dpwY6B
OTP Length    28

พบว่าการ rekey สำเร็จ เพราะ Recovery Key portion ชุดเก่า เมื่อประกอบร่างกันแล้วไม่ตรง

ทดสอบใช้ Recovery Key ชุดใหม่ สร้าง root token จะได้ Encoded Token มา

นำ Encoded Token ไป Decode ด้วย NONCE_OTP ที่ได้ตอน init กระบวนการ generate-root

ทดสอบ new root token login successfully

เสร็จจากเคสแล้วลองหาข้อมูลเพิ่ม ในมุมที่เราเห็น Solution แล้ว พบว่าการลงลึกๆยังคงขาดแคลน ขอฝากไว้ต่อยอดการ Integrate กับ Kubernetes Secrets ด้วยครับ

ตอนที่ทำ wrapper.Decrypt แนะนำเรียกใช้จาก Library เพราะบรรทัดเดียว สะดวกและเห็นผลกระทบสิ่งที่ทำอยู่ได้ชัดเจน
หากไม่อยากเขียนเอง มี Community แชร์โค้ดไว้ สำหรับ go run (as your own risk ควรตรวจสอบโค้ดก่อนรัน) และไม่แนะนำให้รัน Binary โดยตรง

Conclusion & Future plan

ด้วยหลักการของ Shamir's secret sharing (SSS) ถ้าเรามี Secret เราสามารถสร้าง SSS ใหม่ได้หลายชุด ทำให้เราสามารถใช้งาน Vault Operator ที่ Require Recovery Key portion ได้นั่นเอง

ใน Community มีการพูดถึงประเด็นต้องการให้ Recovery Key สามารถ Unseal ได้ด้วย แต่ในเมื่อปัจจุบันยังไม่เปิดให้ทำได้ จึงแนะนำให้ใช้ Bring your own key เพื่อจะได้มี Key ถูกเก็บสำรองไว้ใช้ทำ Auto unseal ได้ กรณีตัว Auto unseal หลักเกิดปัญหา

Rotate certificate in NGINX Open Source without restart

terngr — Fri, 29 Sep 2023 15:52:00 +0000

ตอนนี้ทีมทยอยย้ายเข้า Office ใหม่ตึก OASIS ในรูปเป็นห้องร้อง Karaoke เอ๊ยห้องประชุมขนาดย่อม ไว้ร้อง Karaoke ได้เต็มที่ 8 คน เอ๊ยนั่งทำงานได้เต็มที่ 4 คนครับ

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

server {
    listen              443 ssl;
    server_name         www.example.com;
    ssl_certificate     www.example.com.crt;
    ssl_certificate_key www.example.com.key;
    ...
}

โดยปกติ Certificate จะถูกอ่านจากไฟล์(Disk) แล้วนำไปเก็บใน Memory ตอนที่ start NGINX ฉะนั้นการ Establish connection ก็จะเรียกใช้ key pairs ได้อย่างรวดเร็วผ่าน memory ถ้าเว็บมี server_name เดียว และไม่ได้เปลี่ยนคีย์บ่อยๆ หรือเปลี่ยนแบบมี Downtime ได้ การใช้งานแบบปกติก็ยังเพียงพอ

แต่ถ้าเป็นการที่มี Dynamic name เช่นมีหลายชื่อ มีชื่อเพิ่มเข้าออกบ่อย, หรือกรณีต้องการเปลี่ยน Certificate เป็นตัวใหม่ โดยไม่ให้เกิด Downtime กรณีนี้ เดิมทำได้ทั้งบน NGINX Plus และ NGINX OSS อยู่แล้ว ต่างกันที่วิธีการและ Performance

โดย NGINX Plus ใช้ key-value store ในการเก็บ ซึ่งอยู่บน memory และ load ค่าใหม่จาก Disk เข้า Memory ได้หากต้องการ
NGINX Open Source ใช้วิธีให้อ่านใหม่ทุกครั้ง ซึ่งมีผลกระทบคือเป็นการอ่านจาก Disk ทำให้กระทบกับ Performance กรณีที่ต้อง Establish connection บ่อยๆ

ที่จะเล่าวันนี้มาจาก SSL/TLS Certificate Rotation Without Restarts in NGINX Open Source โดยเป็นการใช้ความสามารถของ NGINX JavaScript Module มาทดแทน key-value store บน NGINX Plus

เริ่มจาก ให้ njs เป็นคนเก็บค่า certificate ไว้ใน Memory

     # Sets an njs function for the variable. Returns a value of cert/key
      js_set $dynamic_ssl_cert main.js_cert;
      js_set $dynamic_ssl_key main.js_key;

จากนั้น NGINX นำค่านี้ไปใช้ตามปกติ ก็จะเป็นค่าอ่านค่า Certificate จาก Memory ซึ่งไม่กระทบกับ Performance แล้วนั่นเอง

      # use variable's data
      ssl_certificate data:$dynamic_ssl_cert;
      ssl_certificate_key data:$dynamic_ssl_key;

เมื่อต้องการเปลี่ยนไปใช้ Certificate ใหม่ สามารถใช้ njs ให้ยกเลิกค่าใน Memory และไปอ่านค่าจากไฟล์ใหม่ได้ทันที, เมื่อ NGINX เรียกใช้ ก็จะเรียกใช้งานจาก Memory ได้ต่อเนื่อง

เบื้องหลังการยกเลิกการใช้งาน Certificate เดิมที่อยู่ใน Memory ให้ไป Load Certificate ใหม่จาก Disk

   location = /clear {
      js_content main.clear_cache;
      # allow 127.0.0.1;
      # deny all;
    }

โดยสรุป เราสามารถที่จะใช้ NJS หรือ NGINX JavaScript Module ซึ่งใช้งานได้ง่ายด้วยภาษา JavaScript และคนทำเว็บคุ้นเคยอยู่แล้ว มาช่วยเพิ่มความสามารถอื่นๆ ให้ NGINX ได้ครับ ในทีนี้คือทำ Function Serve certificate จาก Cache พร้อมความสามารถในการ Reload Certificate ใหม่จาก Disk ลง Cache ได้ด้วยครับ __

NGINX Plus R30, 1 single diagnostic file, telemetry per worker, and more

terngr — Wed, 16 Aug 2023 18:57:28 +0000

NGINX Plus R30 ถือเป็น Commercial Version ซึ่งมีความสามารถมากกว่า มี Reliability และรองรับ Workload ใน Production ได้ดีกว่า NGINX OSS

Diagnostic Package

ฟีเจอร์นี้เข้ามาเสริมเรื่องที่ Subscription จะได้ Support เปิดเคสถามได้, สิ่งที่ตามมาคือ จะทำอย่างไรให้ Support ทำงานได้เร็วขึ้น ได้ข้อมูลเร็วขึ้น และพยายามให้ได้ครบทุกอย่างที่ต้องการในการขอครั้งเดียว
การรัน Script เก็บข้อมูลทุกอย่างจึงเป็นจุดเริ่มต้นครับ แล้ว zip เป็น single diagnostic package ส่งให้ Support
โดยปกติจะมีเครื่องมือ และขั้นตอนช่วย Investigate Diagnostic package ที่ได้ เพื่อระบุปัญหาให้เร็วขึ้น เพราะใช้เครื่องมือทำได้เร็วกว่าทำมือครับ

สิ่งที่ Diagnostic package เก็บไปนั้น NGINX เคลมว่าพยายามทำ Transparency ให้มากที่สุดโดยเปิดเผยว่ารันอะไรบ้าง เก็บอะไรบ้าง

NGINX Information - version, configs, process information, third-party modules, logs, and API stats and endpoints
System information – Host commands (ps, lsof, vmstat, etc.) อันนี้ก็แสดงถึงความ Transparency จาก NGINX
Service information – systemd, etc.
NGINX Agent – Logs and configs (if present) อันนี้เป็น Agent ที่ทำงานร่วมกับ Management Plane เช่น NGINX Management Suite เพื่อช่วยแก้ Configuration และเก็บ Metrics
NGINX App Protect – Logs and configs (if present)
Support package log – Log containing a list of all files collected Diagnostic Script

Connection telemetry per worker

worker ในที่นี้หมายถึง NGINX worker process ครับ
โดยปกติ NGINX จะเริ่มต้นที่ Master Process, จากนั้นสร้าง Worker process มารับ connections โดยจำนวนของ Worker process จะเท่ากับจำนวน CPU Cores โดย Default และปรับตั้งได้

เดิมจำนวน Connection จะนับรวม แต่ตอนนี้สามารถแยกตาม worker ได้ โดยมี PID กำกับ

จะเห็นรายละเอียด Connections และ Requests

เห็น Metrics แล้วมีประโยชน์อย่างไร
จะช่วยปรับค่าใน directive worker_connections
directive worker_connections จะเป็นจำนวน connection ที่มากที่สุดที่แต่ละ Worker process จะเปิดรับได้ Default คือ 512, แต่ Default NGINX configuration file จะใส่ค่าไว้ที่ 1024, ทั้งนี้การปรับตั้ง worker_connections ค่อนข้างมีความจำเป็นในการรับ Load ปริมาณมากๆ เช่นจะตั้ง worker จำนวนเท่าใด แต่ละ Worker ควรรับ Load ไม่เกินเท่าใด ถึงจะได้ประสิทธิภาพที่ดีที่สุด ซึ่ง telemetry ที่เพิ่มมาจะช่วยได้ครับ

เรื่องนี้ ยังอยู่ใน Avoiding the Top 10 NGINX Configuration Mistakes อันดับที่ 1 เพราะการนับจำนวน connection จะนับทั้ง request ที่เปิดจาก Client มายัง NGINX, และนับจาก request ที่เปิดจาก NGINX ไปยัง Upstream ฉะนั้นถ้า Client เรียกมา 1 ครั้ง, แต่ NGINX จะต้องเปิด Connection 2 ครั้ง, นั่นก็แสดงว่า ถ้าเราตั้งค่า worker_connections ไว้ที่ 1024 ก็จะรับ requests พร้อมๆ กันได้ไม่เกิน 512 ต่อ 1 worker นั่นเอง

deprecation of listen http2

เป็น directive ที่ deprecate ครับ สามารถแก้ไขได้โดยเปลี่ยนจาก

listen <port> http2;

เปลี่ยนเป็น

listen <port>
http2 on;

โดย http2 จะเป็น off โดย Default

เรื่องนี้อาจจะนานๆ เห็นครั้งนึง ก็คือ directive depreciation, ผลก็คือถ้าเราอัพเกรด NGINX เป็น version ใหม่ ก็จะทำให้ configuration เดิมใช้ไม่ได้ เป็นจุดนึงที่ต้องเช็คซึ่ง NGINX มี service ช่วยตรวจเช็คให้ครับก่อน upgrade

เคสนี้ถูก Deprecate ใน NGINX-1.25.1 ครับ release เมื่อ 2023-06-13, และ NGINX Plus R30 based on NGINX-1.25.1 จึง Deprecate การใช้ http2 ตามไปด้วย

Ref: HTTP2 module
Ref: NGINX-1.25.1
Ref: NGINX Plus R30 based on NGINX-1.25.1

นอกจากข้างต้น ก็ยังมี Features ย่อยๆ, แก้ Bug และ OS บางตัวที่ End of Life ก็จะถูกหยุด Support ไปด้วยครับ อ่าน Release Note ตัวเต็มได้ที่นี่

Recursion in Terraform, with example

terngr — Sat, 12 Aug 2023 14:29:27 +0000

สัปดาห์ที่แล้วได้พูดถึงการทำ Loop รวมถึงใส่เงื่อนไขในการสร้าง Resources หลายๆ แบบได้โดยใช้ count และ module มาช่วย
คำถามถัดไปคือ Terraform สามารถทำงานในลักษณะ Recursive ได้หรือไม่

TL;DR;

ได้ทดสอบโดยให้เรียก Module ซ้อนกัน(เรียกตัวเอง) พบว่าไม่สามารถเรียกใช้งานได้ จึงสรุปได้ว่าด้วย Terraform ไม่สามารถทำงานในลักษณะแบบ Recursive จริงๆได้(แต่ถ้าเป็นการเรียกซ้อนกัน ที่ไม่ใช่เรียกตัวเอง ยังทำได้ปกตินะครับ แต่เราต้องสร้าง module รองรับไว้)

ถ้าจบแค่นี้อาจจะสั้นไปนิด งั้นเราลองมาแปลง Recursive ให้เป็น Iterative ก่อน

ขอทดสอบด้วยโจทย์ Tower of Hanoi ที่โจทย์ให้หา solution ในการเลื่อน Disk ทั้งหมดจากเสา Source(A) ไปยัง Destination(C) โดยมีเสาพัก 1 เสาคือ Temp(B), กติกาคือ เลื่อนได้ครั้งละ 1 Disk เท่านั้น และห้าม Disk ใหญ่วางทับ Disk เล็ก ทดลองเล่นด้วยตัวเอง

โดยปกติ Tower of Hanoi ถูก Solved ได้ง่ายๆ โดยใช้ Recursive ในที่นี้เราจะให้ Terraform ช่วยแก้จึงต้อง

แปลง Algorithm จาก Recursive เป็น Iterative ก่อน
จากนั้นนำ Count และ Module มาช่วยในการรัน loop แบบ Iterative

#main.tf สำหรับใช้ทำ loop ด้านนอก โดยใช้ count
#ค่าของ count ได้มาจากการแปลง Recursive -> Iterative แล้วดูว่าต้อง move ทั้งหมดเท่าใด

locals {
  n=3
  n_total=pow(2,local.n)-1
}

module "my_module" {
  count = local.n_total
  source = "./my_module"
  n = local.n_total
  i = count.index
  A = "A"
  B = local.n%2==0?"C":"B"
  C = local.n%2==0?"B":"C"
}

output "n_total" {
  value = local.n_total
}
output "my_module" {
  value = module.my_module

#my_module/my_module.tf ที่ใช้รันคำสั่งซึ่งเดิมจะรันใน recursive function
#ในที่นี้ก็คือให้ทำหาค่าเสาที่จะทำการ Move
#ค่าที่ส่งให้ output สามารถนำไปใช้ต่อใน main module ที่เป็นผู้เรียก my_module/my_module.tf ได้

variable "n" {}
variable "i" {}
variable "A" {}
variable "B" {}
variable "C" {}

output "move" {
  value = var.i%3==0 ? "move ${var.A} ${var.C}" : var.i%3==1?"move ${var.A} ${var.B}":"move ${var.B} ${var.C}"

}

ท่า Iterative นี้ จะบอกได้ว่าต้อง move ระหว่างเสาใด แต่ไม่ได้บอกว่าเสาใดคือต้นทางและปลายทาง ทั้งนี้การ Move จะทำได้เพียบแบบเดียวเท่านั้นเพื่อไม่ให้ผิดเงื่อนไข Disk ใหญ่ห้ามทับ Disk ที่เล็กกว่า

หากต้องการรายละเอียดที่เจาะจงว่าเสาใดเป็นต้นทาง จะต้องทำ stack(terraform: list) เพิ่มด้วย โดยเก็บข้อมูลของ Disk ที่อยู่ในแต่ละเสา แล้วใช้เงื่อนไขซ้อนเข้าไปเพื่อเปรียบเทียบความใหญ่ของ Disk เพื่อตัดสินใจว่าระหว่างสองเสาที่ต้อง Move เสาใดควรเป็นต้นทาง(เสาที่ Disk บนสุดเล็กกว่า, หรือเสาปลายทางว่างนั่นเอง)

อีก 1 Use case ที่น่าจะมีประโยชน์คือการทำ directory traversal แบบ recursive, ท่านี้สามารถใช้ command ช่วยรันล่วงหน้าเพื่อสร้างตัวแปรแบบเดียวกับที่ทำใน Tower of Hanoi หรือจะเรียกว่าเป็นการเลี่ยง recursive ก็ได้ครับ

ช่วงนี้เป็นนิมิตหมายที่ดีที่ทุกคนในทีมต่างมีงานเยอะ เลยขอ Terraform ท่าสวยๆ อีก 1 รอบ, สัปดาห์หน้าคาดว่าจะได้ขึ้นโครงร่าง API Security ส่วนประกอบ with example ขอขอบคุณที่ติดตามครับ

ผลลัพธ์ที่ได้จาก Terraform - Recursive -Tower of Hanoi

#n=1
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

my_module = [
  {
    "move" = "move A C"
  },
]
n_total = 1

#n=2
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

my_module = [
  {
    "move" = "move A B"
  },
  {
    "move" = "move A C"
  },
  {
    "move" = "move C B"
  },
]
n_total = 3

#n=3
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

my_module = [
  {
    "move" = "move A C"
  },
  {
    "move" = "move A B"
  },
  {
    "move" = "move B C"
  },
  {
    "move" = "move A C"
  },
  {
    "move" = "move A B"
  },
  {
    "move" = "move B C"
  },
  {
    "move" = "move A C"
  },
]
n_total = 7

Module in Terraform for conditional use cases(Advanced)

terngr — Fri, 04 Aug 2023 16:13:51 +0000

มาต่อเรื่อง Terraform อีกซักนิดครับ การใช้เงื่อนไขใน Terraform สามารถทำได้หลายแบบ จริงๆ เน้นท่าประหลาดๆ สำหรับ Use cases ยากๆ ที่หาจากไหนไม่ได้ ถ้าหลักง่ายๆคิดว่าหาจาก Docs ได้google.com ก่อนอื่นขอปูพื้นนิดนึงครับ

condition

สามารถกำหนดเงื่อนไข precondition และ/หรือ postcondition ได้
เมื่อไม่ได้เงื่อนไขตามที่กำหนด ก็จะไม่สามารถสร้าง resources เสร็จสมบูรณ์ได้ และผลคือ Terraform apply ไม่สำเร็จ

resource "aws_instance" "example" {
  instance_type = "t3.micro"
  ami           = data.aws_ami.example.id

  lifecycle {
    # The AMI ID must refer to an AMI that contains an operating system
    # for the `x86_64` architecture.
    precondition {
      condition     = data.aws_ami.example.architecture == "x86_64"
      error_message = "The selected AMI must be for the x86_64 architecture."
    }

    # The EC2 instance must be allocated a public DNS hostname.
    postcondition {
      condition     = self.public_dns != ""
      error_message = "EC2 instance must be in a VPC that has public DNS hostnames enabled."
    }
  }
}

จะเห็นได้ว่า การใช้ condition, precondition, postcondition ตัว condition เองจะต้องสำเร็จอย่างเดียวเท่านั้นจึงจะทำงานต่อจนจบได้ ถ้าไม่สำเร็จ/ไม่ผ่าน ก็จะ Error แล้วจบการทำงาน แต่ถ้าเป็นเงื่อนไขที่มีทางเลือกมากกว่าหนึ่งล่ะ

ถ้าเป็นการกำหนดค่า จะใช้

<statement> ? <procedure when true> : < procedure when false>

ตัวอย่างเช่น จะหาค่าตำแหน่งว่าเป็น East หรือ West จากตัวเลข

location = myinput < 50 ? "East" : "West"

จะได้ว่า หาก myinput มีค่าน้อยกว่า 50 จริง จะได้ location = "East"
แต่ถ้าเป็นเท็จ ก็คือ myinput มีค่าตั้งแต่ 50 ขึ้นไป จะได้ location = "West" นั่นเอง

จะเห็นได้ว่า เราสามารถกำหนดค่าที่มีทางเลือกมากกว่า 1 ได้ ไม่จำเป็นต้อง True เสมอไป

ถ้าต้องการใช้แบบ switch case หรือหลายทางเลือก ก็สามารถซ้อนกันได้

location = n < 26 ? "North" : n<50 ? "East" : West

Resource

ถ้าเราต้องการใส่เงื่อนใน ในการสร้าง Resource ล่ะ ก็คือถ้าตรงเงื่อนไขให้สร้าง ถ้าไม่ตรงเงื่อนไขไม่สร้าง ซึ่งจะไม่เหมือนกับเคส condition ที่ต้องตรงเงื่อนไขเท่านั้น ไม่ตรงไม่ได้

เคสนี้เราสามารถใช้การ count หรือ for_each ใน resource blog มาช่วยได้
โดยถ้าเงื่อนไขที่กำหนดถูกต้อง ให้ทำการสร้าง resource นี้จำนวน count=1 ก็คือสร้างตามปกตินั่นเอง
แต่ถ้าเงื่อนไขไม่ถูกต้อง ก็ให้ทำการสร้าง resource นี้จำนวน count=0 ก็คือไม่สร้างนั่นเอง

Use case 1

ถ้าต้องการสร้าง resource แบบ count และใส่เงื่อนไขด้วย จะทำอย่างไร
เพราะการสร้าง resource แบบมีเงื่อนไขจะต้องใช้ count, และ terraform ไม่ยอมให้ทำ count ซ้อนกัน

เราจะใช้ความสามารถของ Module มาช่วยโดย
Count=n เพื่อทำการสร้าง Module จำนวน n module
แล้วในแต่ละ Module ค่อยไปสร้าง Resource Blog ตามปกติ ก็จะสามาถใช้ count กับ Resource Blog ในรูปแบบปกติได้ ถ้าตรงเงื่อนไขให้สร้าง ไม่ตรงเงื่อนไขไม่ต้องสร้างได้นั่นเอง

Use case 2

Resource ที่มีการสร้าง objects ข้างในได้จำนวนเท่ากับ 1 หรือมากกว่า 1
เช่น VM ที่มี Disk 1 หรือ มากกว่า 1 ลูก
VM ที่ Attach Network Interface Card 1 หรือมากกว่า 1 ใบ
เราสามารถสั่งให้ Terraform Resource สร้าง Disk ลูกที่ 2 ตามเงื่อนไขได้ไหม(เช่น ถ้ามีการกำหนดขนาด Disk >0 จึงค่อยสร้าง)

จะเห็นได้ว่า ในเคสนี้ การใช้ Count จะเป็นการตัดสินใจสร้าง หรือไม่สร้างในระดับ Resource VM แต่ไม่สามารถตัดสินใจระดับ Object หรือจำนวน Object ใต้ Resource ได้

เราใช้การออกแบบมาแก้ปัญหา โดยสร้าง Resource มา 2 แบบ
แบบแรก มี Disk ลูกเดียว, กำหนดเงื่อนไขการสร้าง Resource นี้ต่อเมื่อค่าความจุของ Disk 2 <1 โดยใช้ Count เป็นตัวกำหนดเงื่อนไข
แบบที่สอง มี Disk สองลูก, กำหนดเงื่อนไขการสร้าง Resource นี้ต่อเมื่อค่าความจุของ Disk 2 >0 โดยใช้ Count เป็นตัวกำหนดเงื่อนไข

สรุป

จะเห็นได้ว่า HCL ถูกออกแบบมาให้ง่ายต่อ Human ในการเข้าใจและใช้งาน แต่ไม่ได้ออกแบบมาในเชิงการ Programming, หากต้องการใส่เงื่อนไขที่ซับซ้อนหน่อยจะต้องออกแรงเพิ่มเป็นครั้งๆ ไป โดยใช้การทำเงื่อนไขที่ HCL มีให้ใช้คือ "? :" และ module
เราอาจใช้งาน module เกือบเป็น function ที่ถูกเรียกมาใช้งานก็ได้ เพราะสามารถไปทำชุดงานอีกชุด(อีก Folder) ได้ และ return ค่าได้ แต่ระวังเรื่องเงื่อนไขการเรียก Module ไม่สามารถกำหนดได้ เหตุผลคือการเรียกโมดูลต้องตายตัว จะเรียกตามเงื่อนไขไม่ได้ ต้องเรียกหรือไม่เรียกเลยเท่านั้น ในทีนี้ก็คือต้องเรียกตลอด แล้วค่อยใส่เงื่อนไขไว้ใต้ module อีกทีนั่นเองครับ

Transform list to map in Terraform(end)

terngr — Mon, 24 Jul 2023 05:36:30 +0000

Product ส่วนใหญ่ทำมาเพื่อให้ชีวิตง่ายขึ้น แน่นอนว่า Series นี้ว่าด้วยความง่าย คือให้ผู้ใช้ Terraform ใส่สิ่งที่ต้องการเฉพาะที่จำเป็น แล้วสร้าง Resources ออกมาตามที่ต้องการ

อ่านตอนที่ 1,2
1: ทำไมใช้ for_each แทน count ใน terraform
2: Enumerate the Variables in Terraform.

ตอนนี้เป็นตอนสุดท้ายครับ จะแปลง List ที่เราได้ Enumerate ออกมา แปลงเป็น map

การเป็น map จะต้องมี key:value ฉะนั้นการแปลง list เป็น map เราจะต้องระบุ key ให้ได้เสียก่อน

Key จะต้อง unique ด้วย ก็คือไม่ซ้ำกัน เช่นจะมี user 2 ค่าไม่ได้ ในที่นี้ก็คือจะมีเครื่องที่มีตัว key เดียวกันไม่ได้นั่นเอง

ในบทความก่อนหน้า(ตามลิงค์ด้านบน) เราได้สร้าง list ของแต่ละเครื่องออกมาแล้ว หนึ่งในนั้นคือ name ซึ่งประกอบไปด้วย Group name รวมกับลำดับใน Group นั้น ซึ่งมีความ Unique จึงสามารถมานำ name ตรงนี้มาใช้เป็น key ให้กับ map ที่จะสร้างได้

ส่วนถัดมาคือ value, ก็คือ Property ของแต่ละ key หรือแต่ละ Resource นั่นเอง
ในตัวอย่างจะเป็น Property ของ VM ก็คือจะนำค่าจาก property ใน list ก่อนหน้ามาใช้ได้เลยนั่นเอง

จากตอนก่อนหน้า เราทราบแล้วว่าต้องการสร้าง map, และ map ใช้ {} นั่นเอง

การสร้าง key:value ใน map ใช้สัญลักษณ์ =>

ตอนก่อนหน้า เราได้ใส่ index ของ vm ในแต่ละ group แล้ว แต่ยังไม่มี global index สำหรับทุกๆ VM ซึ่งเราจะใส่ในขั้นตอนนี้ โดยใช้เป็น
for indeex, i in local.vm_list
จะได้ว่า i จะเป็น Element แต่ละตัวใน local.vm_list
และ index จะเป็น incremental เริ่มที่ 0, 1, 2 ไปในแต่ละ element i ใน local.vm_list

นำด้านบนมาประกอบกัน จะทำการสร้าง map ได้ดังนี้ครับ

vm_map = {for index, i in local.vm_list: i.name => {

ในเคสนี้ จะใช้ loop ชั้นเดียว เพราะ local.vm_list นั้นถูก Enumerate มาเป็นข้อมูลแต่ละ Resource(VM) ตั้งแต่ขั้นตอนก่อนหน้า(ซึ่งตอนนั้นทำ Loop 2 ชั้น คือ Group และ VM และแต่ละ Group ไปให้แล้ว)

จากนั้นก็เหลือขั้นตอนการให้ค่า value ที่จะคู่กับ key ที่เป็น name
value ที่ใช้จะเลือกเป็น list หรือเป็น map ในกรณีนี้แต่ละ resource มี Unique key และไม่มีซ้ำ ฉะนั้นจึงควรเลือกเป็น key โดยมี key ดังนี้ name, group, cpu, memory, index, index_all(ค่า Global Index ที่ได้จาก index ที่ใส่เพิ่มมาในบรรทัด for นั่นเอง)

เมื่อประกอบ loop และการให้ค่าใน value เข้าด้วยกัน จะได้ดังนี้

  vm_map = {for index, i in local.vm_list: i.name => {
        name  = i.name
        group = i.group
        cpu   = i.cpu
        memory= i.memory
        index = i.index
        index_all = index+1
  }}

ฉะนั้น สามารถสรุปขั้นตอนการแปลงค่าจาก list อย่างง่าย ให้ Enumerate ออกมาเป็น Map ได้ดังนี้
Step 0: สารตั้งตั้น

vm = tolist([                                                                                                                                                                                                      {                                                                                                                                                                                                                  "count" = 2                                                                                                                                                                                                      "cpu" = 2                                                                                                                                                                                                        "group" = "GropuA"                                                                                                                                                                                               "memory" = 2048                                                                                                                                                                                                },                                                                                                                                                                                                               {                                                                                                                                                                                                                  "count" = 1                                                                                                                                                                                                      "cpu" = 1                                                                                                                                                                                                        "group" = "GroupB"                                                                                                                                                                                               "memory" = 1024                                                                                                                                                                                                },                                                                                                                                                                                                               {                                                                                                                                                                                                                  "count" = 0                                                                                                                                                                                                      "cpu" = 2                                                                                                                                                                                                        "group" = "GroupC"
    "memory" = 2048
  },
])

Step 1:
Enumerate ด้วย loop 2 ชั้น ได้ list ของ VM แต่ละเครื่อง พร้อม Property

vm_list = tolist([
  {
    "cpu" = 2
    "group" = "GropuA"
    "index" = 1
    "memory" = 2048
    "name" = "GropuA-1"
  },
  {
    "cpu" = 2
    "group" = "GropuA"
    "index" = 2
    "memory" = 2048
    "name" = "GropuA-2"
  },
  {
    "cpu" = 1
    "group" = "GroupB"
    "index" = 1
    "memory" = 1024
    "name" = "GroupB-1"
  },
])

Step 2:
แปลง list เป็น map และเพิ่ม Global Index ให้กับแต่ละ VM ฉะนั้นแต่ละ VM จะมีทั้ง Global Index และ local index ของ group ที่ตนเองอยู่นั่นเอง

vm_map = {
  "GropuA-1" = {
    "cpu" = 2
    "group" = "GropuA"
    "index" = 1
    "index_all" = 1
    "memory" = 2048
    "name" = "GropuA-1"
  }
  "GropuA-2" = {
    "cpu" = 2
    "group" = "GropuA"
    "index" = 2
    "index_all" = 2
    "memory" = 2048
    "name" = "GropuA-2"
  }
  "GroupB-1" = {
    "cpu" = 1
    "group" = "GroupB"
    "index" = 1
    "index_all" = 3
    "memory" = 1024
    "name" = "GroupB-1"
  }
}

Enumerate the Variables in Terraform.

terngr — Sat, 22 Jul 2023 15:10:45 +0000

ความเดิมตอนที่แล้ว เราสามารถสร้างชุด VM ที่ซับซ้อนพร้อมกันหลายๆ ชุด โดยระบุแค่ค่าตั้งต้นเพียงเล็กน้อย
ทำไมใช้ for_each แทน count ใน terraform

ในตอนนี้เราจะ Enumerate ค่าใน list สั้นๆตั้งต้น ออกมาเป็นชุดที่แสดงข้อมูล VM แต่ละเครื่องแบบละเอียด เพื่อนำไปใช้ต่อกันครับ

ตอนนี้อาจจะซับซ้อนหน่อย แต่แสดงให้เห็นว่าเราสามารถเล่นแร่แปรธาตุและทำอะไรๆ กับ Variable บน Terraform ได้มากระดับหนึ่งทีเดียว ซึ่งหากต้องการ Customize code แบบ Programming มากขึ้นก็สามารถไปท่า CDK, SDK integration ได้ด้วย

เราทราบแล้วว่าการสร้าง Resources ด้วย for_each จะรับค่าจาก map หรือ set of strings เท่านั้น

สารตั้งต้น ทำให้สั้นเพื่อง่ายต่อการใช้งาน

ปลายทางที่ต้องการ จัดให้อยู่ในรูปแบบ Map โดยแจกแจง Properties ของแต่ละ VM เพื่อใช้ร่วมกับ for_each

Step 0:

สารตั้งต้น ต้องการสร้างเครื่องจำนวน 2 Group ชื่อว่า GroupA และ GroupB
โดย GroupA ให้สร้าง 2 เครื่อง ให้แต่ละเครื่องมี CPU=2 และ memory=2048
ส่วน GroupB ให้สร้าง 1 เครื่อง ให้แต่ละเครื่องมี CPU=1 และ memory=1024

vm = tolist([                                                                                                                                                                                                      
  {                                                                                                                                                                                                                  
    "group" = "GroupA"                                                                                                                                                                                               
    "count" = 2                                                                                                                                                                                                      
    "cpu" = 2                                                                                                                                                                                                        
    "memory" = 2048                                                                                                                                                                                                
  },                                                                                                                                                                                                               
  {                                                                                                                                                                                                                  
    "group" = "GroupB"                                                                                                                                                                                               
    "count" = 1                                                                                                                                                                                                      
    "cpu" = 1                                                                                                                                                                                                        
    "memory" = 1024                                                                                                                                                                                                
  },                                                                                                                                                                                                               
  {                                                                                                                                                                                                                  
    "group" = "GroupC"                                                                                                                                                                                               
    "count" = 0                                                                                                                                                                                                      
    "cpu" = 2                                                                                                                                                                                                        
    "memory" = 2048                                                                                                                                                                                                
  },                                                                                                                                                                                                             ])

Step 1:

ใช้ for loop 2 ชั้น
โดย loop ชั้นแรก จะกวาดตามจำนวน Element ใน var.vm ซึ่งในที่นี้ก็คือจะกวาดตามจำนวน Group นั่นเอง ซึ่งในที่มี 3 Group คือ "GroupA", "GroupB", "GroupC"

loop ชั้นที่สอง จะกวาดตามจำนวนตัวแปร count ที่อยู่ใต้ element แต่ละตัวใน loop ชั้นแรก ซึ่งอ้างถึงตัวแปร count ได้จากตัวแปร i_name.count
ฉะนั้นในชั้นนี้ จะวิ่งตามจำนวนเครื่องที่ต้องการในแต่ละ Group นั่นเอง โดย
GroupA มีค่า Count=2 ก็จะมีการทำซ้ำ(loop) 2 รอบ,
GroupB มีค่า Count=1 ก็จะมีการทำซ้ำ(loop) 1 รอบ,
GroupA มีค่า Count=0 ก็จะมีการทำซ้ำ(loop) 0 รอบ

เมื่อรัน loop ชั้นแรกและชั้นที่สองเสร็จ จะได้การทำซ้ำ(loop) ทั้งหมด 3 รอบ เท่ากับจำนวนเครื่องที่ต้องการพอดี

หากปรับตัวเลข เป็นจำนวนที่ซับซ้อนขึ้น ก็จะได้การทำซ้ำที่มากขึ้นตาม เช่น GroupA Count=7, GroupB count=20, GroupC count=5 ก็จะได้จำนวนเครื่องทั้งหมด 32 เครื่องนั่นเอง

การทำ loop 2 ชั้น ตามจำนวน Group และตามค่าของ count ในแต่ละ Group

    for i_index, i_name in var.vm : [
      for j_index in range(0, i_name.count) : {

Step 2:

สิ่งที่ทำในแต่ละรอบ การสร้างตัวแปรค่าใหม่ขึ้นมาจากค่าตัวแปรเดิม
จาก Step 1 เราได้สร้าง Loop 2 ชั้น เพื่อให้ทำซ้ำจำนวนรอบเท่ากับจำนวนเครื่องที่ต้องการได้แล้ว

ขั้นนี้ เราจะต้องทำสิ่งที่ต้องทำในแต่ละรอบ นั่นก็คือการกำหนดค่าให้กับ VM ในแต่ละรอบนั่นเอง

ตัวอย่างเช่น Loopชั้นแรกของ GroupA, Loopชั้นที่สอง ของ count=0 จะสร้าง VM สำหรับ GroupA โดยมี Index ของ GroupA เป็น count+1=1, และกำหนดค่า CPU, Memory ตาม GroupA

จากนั้น จะเป็น Loopชั้นแรกของ GroupA, แต่ Loop ชั้นที่สอง ของ count=1

ส่วนใน Loop ของ Group B ก็ทำเช่นเดียวกัน โดย Loop ชั้นแรกคือ GroupB, และ Loop ชั้นที่สองจะทำตามจำนวนของ count ซึ่งครั้งแรกคือ count=0 ก็จะสร้าง VM สำหรับ GroupB โดยมี Index ของ GroupB เป็น count+1=1, และกำหนดค่า CPU, Memory ตาม GroupB

การกำหนดค่าให้กับ loop แต่ละรอบ ตามค่า Group และค่า count

        name  = "${i_name.group}-${j_index+1}"
        group = i_name.group
        cpu   = i_name.cpu
        memory= i_name.memory
        index = j_index+1

Step 3:

ประกอบ Step 1 และ 2 เข้าด้วยกัน
การประกอบ มีสิ่งที่ต้องทราบก่อนคือ
การใช้ (), [], {}
() ใช้ต่อท้าย Function เช่น flatten()
[] ใช้กับ list
{} ใช้กับ map

จากตัวแปรตั้งต้น เป็น list ของแต่ละ Group เพื่อให้เพิ่ม list ได้จำนวนมาก หรือเพิ่ม Group ได้จำนวนมากนั่นเอง ขั้นนี้ใช้ [], และเมื่อเข้าไปในแต่ละ Group จะเป็น map เพราะมี key: value ที่แน่นอน ก็คือ group, count, CPU, Memory ขั้นนี้ใช้ {}

ทั้งหมดที่ได้มา เนื่องจากเป็น map ซ้อนอยู่ใต้ชั้นของ list อีกที จึงนำมา Flatten ด้วย Function flatten ซึ่งใช้ () นั่นเอง

ชั้นนอกสุดจะเป็น function distinct() ทำการเช็คว่ามีค่าซ้ำไหม หากมีค่าใน list 2 ตัวที่ซ้ำกันก็จะนำออก
นำข้างต้นมารวมกัน จะได้เป็นการใช้งาน loop 2 ชั้น กับ list of map

  vm_list = distinct(flatten([
    for i_index, i_name in var.vm : [
      for j_index in range(0, i_name.count) : {
        name  = "${i_name.group}-${j_index+1}"
        group = i_name.group
        cpu   = i_name.cpu
        memory= i_name.memory
        index = j_index+1
      }
    ]
  ]))

สำหรับในบรรทัด for i_index, i_name in var.vm : [
โดยปกติจะใช้ i_name เพื่อแทน element แต่ละตัวใน var.vm ซึ่งในที่นี้ก็คือแต่ละ Group นั่นเอง
แต่ครั้งนี้มีการใส่ i_index เพิ่มเข้ามาด้วย โดยจะแทน increment หรือการนับลำดับนั่นเอง ซึ่งสามารถนำ i_index ไปอ้างอิงใช้งานต่อได้หากต้องการใส่ลำดับแบบ Global เข้าไปเพิ่มเติม นอกเหนือจากการใช้ j_index ซึ่งเป็นลำดับเฉพาะแต่ละใน Group เท่านั้น

ในครั้งนี้เราจะไม่ได้ใส่ค่า i_index เข้าไป เพราะจะมีการใส่ลำดับทั้งหมด(global index) ในขั้นตอนการทำ map ขั้นสุดท้ายเพียงครั้งเดียวนั่นเอง

ทำการรัน จะได้

vm_list = [
{
    "cpu" = 2
    "group" = "GroupA"
    "index" = 1
    "memory" = 2048
    "name" = "GroupA-1"
  },
  {
    "cpu" = 2
    "group" = "GroupA"
    "index" = 2
    "memory" = 2048
    "name" = "GropuA-2"
  },
  {
    "cpu" = 1
    "group" = "GroupB"
    "index" = 1
    "memory" = 1024
    "name" = "GroupB-1"
  },
]

สรุปในตอนนี้ เราได้ทำการ Enumerate Variable จากชื่อ Group และ จำนวน มาใส่ในตัวแปร list พร้อมทั้งระบุชื่อ Group, ลำดับ, Property ที่ต้องการซึ่งในที่นี้คือ CPU และ Memory

ตอนถัดไปจะทำการ construct map variable ขึ้นมาใช้งานครับ

1: ทำไมใช้ for_each แทน count ใน terraform
2: Enumerate the Variables in Terraform.
3: Transform list to map in Terraform

ทำไมใช้ for_each แทน count ใน terraform

terngr — Fri, 14 Jul 2023 21:32:33 +0000

TL;DR

ขอออกตัวก่อนว่า for_each และ count ต่างก็มีความเด่นในตัวเองซึ่งต้องเลือกใช้ให้เหมาะสมตาม Use cases ครับ โดย for_each สามารถใช้ในเคสที่ Advanced ได้ด้วย แต่ถ้าเคสธรรมดาๆใช้ count จะเขียนได้เร็วกว่า

ท่านที่คุ้นกับ Terraform count อยู่แล้ว ข้ามไปอ่าน for_each ได้เลยครับ

Terraform คือ

Infrastructure as Code คือเราสามารถเขียน Infrastructure ที่ต้องการในรูปแบบของ Code(HashiCorp Configuration Language - HCL) จากนั้นใช้ Provider เชื่อมต่อไปยัง Infrastructure ต่างๆ เช่น Cloud เพื่อสั่งการให้สร้าง Infrastructure ตามแบบที่เราระบุไว้ใน Code

การสร้าง Resource

เช่นการสร้าง EC2 สามารถทำได้โดยเขียน Block

resource "aws_instance" <name> {
  ...
}

หากต้องการ EC2 แบบเดียวกัน แต่เพิ่มเป็น 5 Instances สามารถเขียน count = 5 ได้เลยโดยไม่ต้องทำ Block resource ใหม่

resource "aws_instance" <name> {
  count = 5
  ...
}

ทำการรัน จะได้ EC2 จำนวน 5 Instances
ดูตัวอย่างการใช้ count ได้ที่ Create 10 AWS EC2 with Terraform แบบเร็วๆ

ถ้าเราต้องการ EC2 เพิ่มอีก 2 Instances โดยให้มี Atrributes ต่างกัน เช่น
5 Instances แรก กำหนดให้ instance_type = t2.micro
2 Instances ถัดมา กำหนดให้ instance_type = t2.small
จะพบว่าเราไม่สามารถแก้ count จาก 5 เป็น 7 ได้ เพราะจะได้ instance_type เหมือนกันทั้ง 7 Instances

เราอาจเพิ่ม Block ขึ้นมาอีก Block หนึ่งก็ได้ โดยระบุจำนวน Instances และ instance_type ให้ต่างกัน ดังนี้

resource "aws_instance" <name> {
  count = 5
  instance_type = "t2.micro"
  ...
}

resource "aws_instance" <name2> {
  count = 2
  instance_type = "t2.small"
  ...
}

หากต้องการสร้าง resources ที่ Attributes ต่างออกไปจากนี้อีก เช่น instance_type, ami, tag, subnet_id, key_name, etc ก็ต้องสร้าง Block ใหม่เพิ่มเรื่อยๆ

for_each

ต่างจาก count ที่รับค่าเป็น Integer, โดย for_each รับค่าเป็น set หรือ map โดยจะสร้าง Resources ประเภทนั้นๆ ตามค่าใน set หรือ map

HashiCorp: The for_each Meta-Argument
The for_each meta-argument accepts a map or a set of strings, and creates an instance for each item in that map or set.

ในที่นี้ หากเราใช้ set จะไม่รองรับ Use case ที่ต้องการปรับแต่งมากกว่า 1 Attribute จึงต้องใช้ map โดยแต่ละ item ใน map จะเก็บ set ของ Attributes เช่น instance_type, group_name, etc รวมไปถึงจำนวน Instances ที่ต้องการได้อีกด้วย

** ตัวอย่าง map variable ที่ใช้กับ for_each เพื่อสร้าง
Application จำนวน 3 Instances, instance_type = "t2.micro"
Web จำนวน 2 Instances, instance_type = "t2.small

  - local_aws_vm_map  = {
      - application-1 = {
          - group     = "application"
          - index     = 1
          - index_all = 1
          - name      = "application-1"
          - type      = "t2.micro"
        }
      - application-2 = {
          - group     = "application"
          - index     = 2
          - index_all = 2
          - name      = "application-2"
          - type      = "t2.micro"
        }
      - application-3 = {
          - group     = "application"
          - index     = 3
          - index_all = 3
          - name      = "application-3"
          - type      = "t2.micro"
        }
      - web-1         = {
          - group     = "web"
          - index     = 1
          - index_all = 4
          - name      = "web-1"
          - type      = "t2.small"
        }
      - web-2         = {
          - group     = "web"
          - index     = 2
          - index_all = 5
          - name      = "web-2"
          - type      = "t2.small"
        }
    }

สร้าง EC2 instances ตาม local_aws_vm_map ที่กำหนดได้ดังนี้

resource "aws_instance" "aws_vm_map" {
  for_each = local.aws_vm_map
  ami           = var.ubuntu22_ami
  instance_type = each.value.type
  key_name                    = var.key
  subnet_id                   = var.subnet
  associate_public_ip_address = false

  tags = {
    Name    = "${var.prefix}-${each.value.name}"
    Name_without_prefix = each.value.name
    Group   = each.value.group
    Index   = each.value.index
    Index_all = each.value.index_all
    Creator = "Sukkarin"
  }
}

จะได้
Application จำนวน 3 Instances, instance_type = "t2.micro"
Web จำนวน 2 Instances, instance_type = "t2.small"
และมี Attributes, เช่น tag Name, Group, Index, Index_all(Index แบบนับรวม EC2 ทุก Group), etc แตกต่างกันไปในแต่ละ Instances หรือก็คือสามารถกำหนด Attribute ได้ตามต้องการนั่นเอง

แม้ตอนนี้เราสามารถสร้าง EC2 โดยกำหนด Attributes ได้ตามต้องการ แต่ปัญหาจะมาตกอยู่ที่ variable local_aws_vm_map, กรณีเช่นหากต้องการ Application VM จำนวน 100 Instances จะต้องเขียน item ใน map เพิ่ม 100 items, และแต่ละ item จะต้องระบุ Attributes ของ VM นั้นๆ ด้วย

Thanks to Terraform ที่เราสามารถแปลงค่าใน Variable ต่างประเภทไปมาได้, Enumerate ค่าจาก Variable หนึ่ง แยกย่อยลงไปในแต่ละ Items ได้ เคสนี้เราสามารถกำหนด Attributes ของ EC2 ที่ต้องการได้ง่ายมากดังนี้

aws_vm = [
    {
      "group" = "application"
      "count" = 3
      "type"  = "t2.micro"
    },
    {
      "group" = "web"
      "count" = 2
      "type"  = "t2.small"
    }
]

จากนั้นแปลงค่าจาก variable aws_vm ให้เป็น map ชื่อ local_aws_vm_map ซึ่ง Enumerate Attributes ของแต่ละ EC2 Instances ออกมาเรียบร้อยแล้วตามตัวอย่าง variable type map

ทดสอบ เพิ่ม group database กำหนดให้ count = 1 และ type = "t2.medium" ซึ่งใช้งานได้ทันทีโดยไม่ต้องสร้าง aws_instance block เพิ่มอีก

aws_vm = [
    {
      "group" = "application"
      "count" = 3
      "type"  = "t2.micro"
    },
    {
      "group" = "web"
      "count" = 2
      "type"  = "t2.small"
    },
    {
      "group" = "database"
      "count" = 1
      "type"  = "t2.medium"
    }
]

เมื่อทำการแปลงค่าให้ aws_vm ให้เป็น map variable จะได้ดังนี้

local_aws_vm_map = {
  "application-1" = {
    "group" = "application"
    "index" = 1
    "index_all" = 1
    "name" = "application-1"
    "type" = "t2.micro"
  }
  "application-2" = {
    "group" = "application"
    "index" = 2
    "index_all" = 2
    "name" = "application-2"
    "type" = "t2.micro"
  }
  "application-3" = {
    "group" = "application"
    "index" = 3
    "index_all" = 3
    "name" = "application-3"
    "type" = "t2.micro"
  }
  "database-1" = {
    "group" = "database"
    "index" = 1
    "index_all" = 6
    "name" = "database-1"
    "type" = "t2.medium"
  }
  "web-1" = {
    "group" = "web"
    "index" = 1
    "index_all" = 4
    "name" = "web-1"
    "type" = "t2.small"
  }
  "web-2" = {
    "group" = "web"
    "index" = 2
    "index_all" = 5
    "name" = "web-2"
    "type" = "t2.small"
  }
}

terraform apply จะเห็น EC2 instance ใหม่ชื่อ database ถูกสร้างขึ้นมา โดย type="t2.medium"

การแปลงค่า variable จาก aws_vm ไปที่ map variable local_aws_vm_map เพื่อไม่ให้เนื้อหายาวเกินไปขอขึ้นใหม่อีกตอนครับ เพราะมีเรื่อง Variables, function, loop เกี่ยวข้อง, สำหรับ Code ที่ใช้ในการแปลงค่าเป็นโค้ดของผู้เขียนบทความเองตามนี้ครับ

locals {
  # Create "list" of AWS infrastructure resources
  aws_vm_list = distinct(flatten([
    for i_index, i_name in var.aws_vm : [
      for j_index in range(0, i_name.count) : {
        name  = "${i_name.group}-${j_index+1}"
        group = i_name.group
        type  = i_name.type
        index = j_index+1
        #index_all=??
      }
    ]
  ]))

  # Create "map" of AWS infrastructure resources
  aws_vm_map = {for index, i in local.aws_vm_list: i.name => {
        name  = i.name
        group = i.group
        type  = i.type
        index = i.index
        index_all = index+1
  }}
}

First Publicly Published: July 15, 2023

1: ทำไมใช้ for_each แทน count ใน terraform
2: Enumerate the Variables in Terraform.
3: Transform list to map in Terraform

Gateway API คือขั้นกว่าของการทำ Ingress บน Kubernetes

terngr — Fri, 07 Jul 2023 23:28:45 +0000

Image credit: https://unsplash.com/photos/_UIVmIBB3JU

TL;DR

Kubernetes Gateway API เป็นการทำ Fine-grain แยกจาก Ingress Resource เดิมเพื่อให้ทีม Infra และทีม Dev แยกส่วนบริหารจัดการ ตามความรับผิดชอบได้ดีขึ้น

บทความนี้เหมาะกับผู้ที่คุ้นเคยกับ Kubernetes และเคยใช้งาน Ingress Controller บน Kubernetes

Kubernetes Ingress คืออะไร

Kubernetes เป็นระบบบริหารจัดการ Container, ซึ่ง Container ทำงานอยู่บน Overlay network ไม่สามารถถูกเข้าถึงหรือเรียกใช้งานตรงๆ ได้ จึงต้องมี Ingress มาเป็นตัวกลางเพื่อให้เข้าใช้งาน Applications ที่รันอยู่ใน Kubernetes ได้

Ref: NGINX Ingress Controller
ในภาพจะใช้ NGINX มาทำเป็น NGINX Ingress Controller ครับโดยมีขั้นตอนคือ

สร้าง NGINX Ingress Controller กล่องสีเขียว เราอาจเทียบได้กับการสร้าง Reverse Proxy ขึ้นมาใช้งาน 1 ชุดก็ได้
สร้าง Ingress โดยผ่าน Kubernetes API กล่องสีขาว เราอาจเทียบได้กับการ Configure Reverse proxy ให้ listen และส่ง Load ไปยัง Backend(services) ที่ต้องการก็ได้, ให้สังเกตคำว่า Kubernetes API โดย API ในที่นี้หมายถึง Interface ที่รองรับการติดต่อแบบ Application Programming(API = Application Programming Interface) หรือเราสามารถสร้าง Ingress โดยเรียกผ่าน API ได้นั่นเองครับ

Gateway API ไม่เกี่ยวข้องกับ API Gateway

เรื่องนี้ให้ดูที่คำหลัก โดย API Gateway คำหลักคือ API เป็นการจัดการการเข้าถึง API Services ต่างๆ โดยนำ Gateway มาวางคั่นแล้วบริหารจัดการผ่าน Gateway นั้น จึงเรียกว่า API Gateway สิ่งสำคัญคือเราจะต้องมี API Services เสียก่อน ถึงจะบริหารจัดการได้ ถ้ามีแต่ API Gateway ก็จะไม่มีอะไรให้บริหารจัดการนั่นเอง

Gateway API คำหลักคือ Gateway ในที่นี้คือทางเข้าใช้งาน ก็คือทางเข้าใช้งาน Applications ที่รันอยู่ใน Kubernetes นั่นเองครับ ส่วน API เป็นส่วนเสริมที่แสดงถึงการเป็น Interface(Application Programming Interface) ว่าเราสามารถสร้างทางเข้า(Gateway) นี้ผ่าน API ได้

ฉะนั้น API Gateway คือการบริหารจัดการการเข้าใช้งาน API Services ต่างๆ อาจเกี่ยวหรือไม่เกี่ยวกับ Kubernetes ก็ได้
แต่ Gateway API โฟกัสไปที่ทางเข้าไปยัง Application ใน Kubernetes ฉะนั้นจึงเป็นเคสของ Kubernetes เท่านั้น ส่วน Applications ที่รันอยู่ภายใน Kubernetes อาจเป็นหรือไม่เป็น API Services ก็ได้

เข้าเนื้อหา ทำไมต้องใช้ Gateway API

จากภาพ NGINX Ingress Controller ตามกล่องสีเขียวด้านบน ทำหน้าที่สองข้อด้วยกันคือ

รับ requests จากภายนอก การเลือกเปิดรับ Port, Name(FQDN), Policies , TLS termination ซึ่งงานแบบนี้มักเป็นงานของทีม Infra
ส่งต่อ requests ไปยัง services หลังบ้าน รวมไปถึงการทำ A/B testing, การอัพเกรด App version, Traffic splitting, header manipulating ซึ่งเป็นงานของทีม App

จะเห็นได้ว่าทั้งสองงานถูกดูแลด้วยทีม 2 ทีม ซึ่งท่าที่ใช้ทำ Ingress แบบเดิมๆ นั้นจะใช้วิธีการสร้าง Kubernetes Resource ชื่อว่า kind: ingress หรือเรียกได้ว่ามี Kubernetes Resource แค่หนึ่งเดียวที่ทุกทีมต้องมาใช้งานร่วมกัน ทำให้มีการให้สิทธิ์ที่มากเกินจำเป็น หรือหากถูกดูแลโดยทีมเดียว เมื่ออีกทีมต้องการแก้ไขก็ต้องร้องขอ ทำให้เกิดความยุ่งยากและล่าช้า

Ref: Gateway API
Pain point นี้ถูกแก้ด้วย Kubernetes Resources ตัวใหม่ชื่อว่า gateway และ HTTPRoute โดยทีม Infra สามารถบริหารจัดการ kind: gateway โดยจัดการ Name, Certificates และ Policies ได้ ส่วนทีม App สามารถจัดการ kind: HTTPRoute เช่น Path, การจัดการ App ต่างๆ ได้ด้วยตนเอง โดยเลือกจับคู่กับ gateway ที่มีให้ใช้งานได้

ตัวอย่างการใช้งานสร้าง kind: gateway สำหรับทีม Infra โดยตั้งชื่อ Gateway และระบุ Name, Port, Policies ที่ต้องการ

การใช้งานสร้าง kind: HTTP Route สำหรับทีม Dev โดยเลือกใช้ Gateway, ระบุ Path และ Services ที่ต้องการ

ลงไปดูมีการ Implement NGINX Pod แบบเดียวกับท่า Ingress ปกติครับ และสามารถต่อแบบ NodePort และรองรับ Cloud LoadBalancer ของ AWS, Azure, GCP ได้
Ref: NGINX Implementation

หนึ่งในท่าที่ทำได้คือการ Map NodePort ซึ่งทำในลักษณะเดียวกันกับ Ingress ปกติ

จะเห็นได้ว่าฝั่ง NGINX ทั้ง NGINX pod และ Services เรียกได้ว่าถอดแบบมาจากการทำ NGINX Ingress Controller ปกติเลย แต่จุดต่างจะอยู่ที่ตัว Kubernetes Resources ที่การทำ Gateway API มี Resources ให้ใช้มากกว่า ทำ Granular ได้ดีกว่า โดย Resources ทั้งหมดที่มีให้ใช้งานคือ GatewayClass, Gateway, HTTPRoute, TCPRoute, Service

Gateway API เมื่อนำมาใช้จะต้อง Implement คู่กับ Gateway(เทียบได้กับกล่องสีเขียวในรูปด้านบน) ซึ่งยังไม่พร้อมใช้งานบน Production

ณ ปัจจุบัน NGINX Ingress Controller เดิมๆ มีการใช้งานมากที่สุดเป็นอันดับ 1 อยู่แล้วครับ และมีความน่าเชื่อถือสูงมากใน Production ฉะนั้น NGINX จึงยังคงแนะนำให้ใช้ NGINX Ingress Controller บน Production

ถ้าต้องการใช้งานแบบแยก Resources เป็น Infra กับ Dev บน Production ยังมีทางเลือก Commercial คือ NGINX Plus Ingress Controller ซึ่งมี CRD เป็น Custom resources ที่ชื่อ kind: Virtualserver และ kind: Virtualserverroute พร้อมใช้งานบน Production มาก่อนหน้านี้ประมาณ 2-3 ปี
อีกตัวหนึ่งที่ GA แล้วคือ Google Kubernetes Engine ครับ