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

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

การจัดสรรภาระงาน NGINX ที่ง่ายขึ้นด้วย Loadcat ทวีต

ในบทช่วยสอนนี้เราจะสำรวจกลไกภายในของไฟล์ เครื่องมือทดลอง ที่ช่วยให้คุณสามารถกำหนดค่าอินสแตนซ์ NGINX ของคุณได้ทันทีเพื่อทำหน้าที่เป็นตัวจัดสรรภาระงานโดยแยกรายละเอียดที่สำคัญทั้งหมดของไฟล์การกำหนดค่า NGINX ออกโดยการจัดเตรียมอินเทอร์เฟซผู้ใช้บนเว็บที่เป็นระเบียบ บทความนี้มีวัตถุประสงค์เพื่อแสดงให้เห็นว่าการเริ่มสร้างเครื่องมือดังกล่าวนั้นง่ายเพียงใด เป็นที่น่าสังเกตว่าโครงการ Loadcat ได้รับแรงบันดาลใจอย่างมากจาก Linode’s โหนดบาลานเซอร์ .

NGINX เซิร์ฟเวอร์และต้นน้ำ

หนึ่งในการใช้งานที่ได้รับความนิยมมากที่สุดของ NGINX คือคำขอพร็อกซีย้อนกลับจากไคลเอนต์ไปยังแอปพลิเคชันเว็บเซิร์ฟเวอร์ แม้ว่าเว็บแอปพลิเคชันที่พัฒนาในภาษาการเขียนโปรแกรมเช่น Node.js และ Go สามารถเป็นเว็บเซิร์ฟเวอร์แบบพอเพียงได้ แต่การมี reverse-proxy อยู่หน้าแอปพลิเคชันเซิร์ฟเวอร์จริงจะให้ประโยชน์มากมาย บล็อก 'เซิร์ฟเวอร์' สำหรับกรณีการใช้งานง่ายๆเช่นนี้ในไฟล์กำหนดค่า NGINX จะมีลักษณะดังนี้:

จุดขายสำหรับ Android

server { listen 80; server_name example.com; location / { proxy_pass http://192.168.0.51:5000; } }

สิ่งนี้จะทำให้ NGINX รับฟังบนพอร์ต 80 สำหรับคำขอทั้งหมดที่ชี้ไปที่ example.com และส่งแต่ละคำขอไปยังแอปพลิเคชันเว็บเซิร์ฟเวอร์ที่ทำงานที่ 192.168.0.51:5000 นอกจากนี้เรายังสามารถใช้ที่อยู่ IP ย้อนกลับ 127.0.0.1 ได้ที่นี่หากเซิร์ฟเวอร์เว็บแอ็พพลิเคชันกำลังทำงานอยู่ภายใน โปรดทราบว่าข้อมูลโค้ดด้านบนขาดการปรับแต่งบางอย่างที่ชัดเจนซึ่งมักใช้ในการกำหนดค่าพร็อกซีย้อนกลับ แต่จะถูกเก็บไว้ด้วยวิธีนี้เพื่อความกะทัดรัด

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

upstream nodes { server 192.168.0.51:5000; server 192.168.0.52:5000; } server { listen 80; server_name example.com; location / { proxy_pass http://nodes; } }

สังเกตว่าเรากำหนดบล็อก 'ต้นน้ำ' ชื่อ 'โหนด' ซึ่งประกอบด้วยเซิร์ฟเวอร์สองเครื่อง แต่ละเซิร์ฟเวอร์ระบุโดยที่อยู่ IP และหมายเลขพอร์ตที่กำลังรับฟัง ด้วยเหตุนี้ NGINX จึงกลายเป็นตัวโหลดบาลานเซอร์ในรูปแบบที่ง่ายที่สุด ตามค่าเริ่มต้น NGINX จะแจกจ่ายคำขอที่เข้ามาในรูปแบบ Round-robin โดยที่คำขอแรกจะถูกส่งไปยังเซิร์ฟเวอร์แรกเซิร์ฟเวอร์ที่สองไปยังเซิร์ฟเวอร์ที่สองและเซิร์ฟเวอร์ที่สามไปยังเซิร์ฟเวอร์แรกและอื่น ๆ

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

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

Loadcat: เครื่องมือกำหนดค่า NGINX

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

โหลดแคท เกิด!

Loadcat สร้างด้วย ไป ยังอยู่ในวัยเด็ก ในขณะนี้เครื่องมือนี้อนุญาตให้คุณกำหนดค่า NGINX สำหรับการทำโหลดบาลานซ์และการยุติ SSL เท่านั้น มีเว็บที่เรียบง่าย GUI สำหรับผู้ใช้ . แทนที่จะดูคุณสมบัติแต่ละอย่างของเครื่องมือให้เราดูสิ่งที่อยู่ข้างใต้ โปรดทราบว่าหากมีคนชอบทำงานกับไฟล์กำหนดค่า NGINX ด้วยมือพวกเขาอาจพบคุณค่าเพียงเล็กน้อยในเครื่องมือดังกล่าว

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

aws Associate Solutions สถาปนิก ใบรับรอง

ในกรณีที่คุณไม่ใช่ ไปวิศวกร ไม่ต้องกังวลเลย ไปคือ ค่อนข้างง่ายและสนุก เริ่มต้นด้วย ยิ่งไปกว่านั้นการใช้งานนั้นตรงไปตรงมามากและคุณควรจะทำตามได้อย่างง่ายดาย

โครงสร้าง

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

• cfg: โหลดแยกวิเคราะห์และจัดเตรียมค่าคอนฟิกูเรชัน
• cmd / loadcat: แพ็กเกจหลักมีจุดเข้าคอมไพล์เป็นไบนารี
• ข้อมูล: มี 'โมเดล' ใช้ที่เก็บคีย์ / ค่าที่ฝังไว้เพื่อการคงอยู่
• feline: มีฟังก์ชันหลักเช่น การสร้างไฟล์คอนฟิกูเรชันกลไกการรีโหลด ฯลฯ
• ui: มีเทมเพลตตัวจัดการ URL ฯลฯ

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

จุดเข้า

เริ่มจากแพ็คเกจหลักสำหรับ Loadcat ซึ่งอยู่ใน“ cmd / loadcatd” ฟังก์ชั่นหลักจุดเริ่มต้นของแอปพลิเคชันทำสามสิ่ง

func main() { fconfig := flag.String('config', 'loadcat.conf', '') flag.Parse() cfg.LoadFile(*fconfig) feline.SetBase(filepath.Join(cfg.Current.Core.Dir, 'out')) data.OpenDB(filepath.Join(cfg.Current.Core.Dir, 'loadcat.db')) defer data.DB.Close() data.InitDB() http.Handle('/api', api.Router) http.Handle('/', ui.Router) go http.ListenAndServe(cfg.Current.Core.Address, nil) // Wait for an “interrupt“ signal (Ctrl+C in most terminals) }

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

ดังที่คุณทราบจากโค้ดเรากำลังโหลดไฟล์คอนฟิกูเรชันตามแฟล็กบรรทัดคำสั่ง“ -config” (ซึ่งมีค่าเริ่มต้นเป็น“ loadcat.conf” ในไดเร็กทอรีปัจจุบัน) ต่อไปเราจะเริ่มต้นองค์ประกอบสองสามส่วน ได้แก่ แพ็คเกจแมวหลักและฐานข้อมูล ในที่สุดเรากำลังเริ่มต้นเว็บเซิร์ฟเวอร์สำหรับ GUI บนเว็บ

การกำหนดค่า

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

struct { Core struct { Address string Dir string Driver string } Nginx struct { Mode string Systemd struct { Service string } } }

และนี่คือลักษณะของไฟล์“ loadcat.conf” ทั่วไป:

[core] address=':26590' dir='/var/lib/loadcat' driver='nginx' [nginx] mode='systemd' [nginx.systemd] service='nginx.service'

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

func LoadFile(name string) error { f, _ := os.Open(name) if os.IsNotExist(err) { f, _ = os.Create(name) toml.NewEncoder(f).Encode(Current) f.Close() return nil } toml.NewDecoder(f).Decode(&Current) return nil }

ข้อมูลและความคงอยู่

พบกัน สายฟ้า . ที่เก็บคีย์ / ค่าแบบฝังที่เขียนด้วย Go แท้ มาเป็นแพ็คเกจพร้อม API ที่เรียบง่ายรองรับการทำธุรกรรมนอกกรอบและเป็น รบกวน เร็ว.

ภายในข้อมูลแพ็คเกจเรามี โครงสร้าง เป็นตัวแทนของเอนทิตีแต่ละประเภท ตัวอย่างเช่นเรามี:

type Balancer struct { Id bson.ObjectId Label string Settings BalancerSettings } type Server struct { Id bson.ObjectId BalancerId bson.ObjectId Label string Settings ServerSettings }

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

เนื่องจาก Bolt เป็นที่เก็บคีย์ - ค่าและไม่รองรับการสืบค้นฐานข้อมูลขั้นสูงเราจึงมีตรรกะฝั่งแอปพลิเคชันที่ทำสิ่งนี้ให้เรา Loadcat ไม่ได้มีไว้สำหรับการกำหนดค่า balancers หลายพันตัวกับเซิร์ฟเวอร์นับพันในแต่ละเซิร์ฟเวอร์ดังนั้นวิธีการที่ไร้เดียงสานี้จึงใช้ได้ดี นอกจากนี้ Bolt ยังทำงานร่วมกับคีย์และค่าที่เป็นชิ้นส่วนไบต์และนั่นคือเหตุผลที่เราเข้ารหัส BSON โครงสร้าง ก่อนจัดเก็บไว้ใน Bolt การใช้งานฟังก์ชั่นที่ดึงรายการ โครงสร้างบาลานเซอร์ จากฐานข้อมูลดังแสดงด้านล่าง:

func ListBalancers() ([]Balancer, error) { bals := []Balancer{} DB.View(func(tx *bolt.Tx) error { b := tx.Bucket([]byte('balancers')) c := b.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { bal := Balancer{} bson.Unmarshal(v, &bal) bals = append(bals, bal) } return nil }) return bals, nil }

ListBalancers ฟังก์ชันเริ่มต้นธุรกรรมแบบอ่านอย่างเดียววนซ้ำคีย์และค่าทั้งหมดภายในที่เก็บข้อมูล 'ตัวปรับสมดุล' ถอดรหัสแต่ละค่าเป็นอินสแตนซ์ของ โครงสร้างบาลานเซอร์ และส่งคืนพวกมันในอาร์เรย์

การจัดเก็บบาลานเซอร์ในถังนั้นแทบจะง่ายพอ ๆ กัน:

ความแตกต่างระหว่างศิลปะกับการออกแบบ

func (l *Balancer) Put() error { if !l.Id.Valid() { l.Id = bson.NewObjectId() } if l.Label == '' { l.Label = 'Unlabelled' } if l.Settings.Protocol == 'https' { // Parse certificate details } else { // Clear fields relevant to HTTPS only, such as SSL options and certificate details } return DB.Update(func(tx *bolt.Tx) error { b := tx.Bucket([]byte('balancers')) p, err := bson.Marshal(l) if err != nil { return err } return b.Put([]byte(l.Id.Hex()), p) }) }

ใส่ ฟังก์ชันกำหนดค่าเริ่มต้นให้กับบางฟิลด์แยกวิเคราะห์ใบรับรอง SSL ที่แนบมาในการตั้งค่า HTTPS เริ่มต้นธุรกรรมเข้ารหัส โครงสร้าง อินสแตนซ์และจัดเก็บไว้ในที่เก็บข้อมูลเทียบกับ ID ของบาลานเซอร์

ในขณะที่แยกวิเคราะห์ใบรับรอง SSL ข้อมูลสองส่วนจะถูกดึงออกมาโดยใช้ การเข้ารหัสแพ็คเกจมาตรฐาน / pem และเก็บไว้ใน SSLOptions ภายใต้ การตั้งค่า ฟิลด์: ชื่อ DNS และลายนิ้วมือ

นอกจากนี้เรายังมีฟังก์ชั่นที่ค้นหาเซิร์ฟเวอร์โดย balancer:

func ListServersByBalancer(bal *Balancer) ([]Server, error) { srvs := []Server{} DB.View(func(tx *bolt.Tx) error { b := tx.Bucket([]byte('servers')) c := b.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { srv := Server{} bson.Unmarshal(v, &srv) if srv.BalancerId.Hex() != bal.Id.Hex() { continue } srvs = append(srvs, srv) } return nil }) return srvs, nil }

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

ใส่ ฟังก์ชันสำหรับเซิร์ฟเวอร์นั้นง่ายกว่ามาก โครงสร้างบาลานเซอร์ เนื่องจากไม่ต้องใช้ค่าเริ่มต้นในการตั้งค่าโค้ดและฟิลด์ที่คำนวณมากนัก

การควบคุม NGINX

ก่อนใช้ Loadcat เราต้องกำหนดค่า NGINX เพื่อโหลดไฟล์กำหนดค่าที่สร้างขึ้น Loadcat สร้างไฟล์“ nginx.conf” สำหรับแต่ละบาลานเซอร์ภายใต้ไดเร็กทอรีโดย ID ของบาลานเซอร์ (สตริงเลขฐานสิบหกแบบสั้น) ไดเร็กทอรีเหล่านี้ถูกสร้างขึ้นภายใต้ไดเร็กทอรี“ out” ที่ cwd ดังนั้นจึงเป็นสิ่งสำคัญที่คุณจะต้องกำหนดค่า NGINX เพื่อโหลดไฟล์การกำหนดค่าที่สร้างขึ้นเหล่านี้ ซึ่งสามารถทำได้โดยใช้คำสั่ง“ รวม” ในบล็อก“ http”:

แก้ไข /etc/nginx/nginx.conf และเพิ่มบรรทัดต่อไปนี้ที่ส่วนท้ายของบล็อก“ http”:

http { include /path/to/out/*/nginx.conf; }

ซึ่งจะทำให้ NGINX สแกนไดเรกทอรีทั้งหมดที่พบภายใต้“ / path / to / out /” ค้นหาไฟล์ชื่อ“ nginx.conf” ภายในแต่ละไดเร็กทอรีและโหลดแต่ละไดเร็กทอรีที่พบ

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

โดนแฮกหมายเลขบัตรเครดิตพร้อมรายละเอียด

type Driver interface { Generate(string, *data.Balancer) error Reload() error }

ตัวอย่างเช่นโครงสร้าง Nginx ภายใต้แพ็คเกจ feline / nginx:

type Nginx struct { sync.Mutex Systemd *dbus.Conn } func (n Nginx) Generate(dir string, bal *data.Balancer) error { // Acquire a lock on n.Mutex, and release before return f, _ := os.Create(filepath.Join(dir, 'nginx.conf')) TplNginxConf.Execute(f, /* template parameters */) f.Close() if bal.Settings.Protocol == 'https' { // Dump private key and certificate to the output directory (so that Nginx can find them) } return nil } func (n Nginx) Reload() error { // Acquire a lock on n.Mutex, and release before return switch cfg.Current.Nginx.Mode { case 'systemd': if n.Systemd == nil { c, err := dbus.NewSystemdConnection() n.Systemd = c } ch := make(chan string) n.Systemd.ReloadUnit(cfg.Current.Nginx.Systemd.Service, 'replace', ch) <-ch return nil default: return errors.New('unknown Nginx mode') } }

สร้าง สามารถเรียกใช้ด้วยสตริงที่มีพา ธ ไปยังไดเร็กทอรีเอาต์พุตและตัวชี้ไปยังไฟล์ บาลานเซอร์ อินสแตนซ์โครงสร้าง Go จัดเตรียมแพ็คเกจมาตรฐานสำหรับเทมเพลตข้อความซึ่งไดรเวอร์ NGINX ใช้เพื่อสร้างไฟล์การกำหนดค่า NGINX สุดท้าย เทมเพลตประกอบด้วยบล็อก 'ต้นน้ำ' ตามด้วยบล็อก 'เซิร์ฟเวอร์' ซึ่งสร้างขึ้นตามวิธีการกำหนดค่าตัวปรับสมดุล:

var TplNginxConf = template.Must(template.New('').Parse(` upstream {{.Balancer.Id.Hex}} { {{if eq .Balancer.Settings.Algorithm 'least-connections'}} least_conn; {{else if eq .Balancer.Settings.Algorithm 'source-ip'}} ip_hash; {{end}} {{range $srv := .Balancer.Servers}} server {{$srv.Settings.Address}} weight={{$srv.Settings.Weight}} {{if eq $srv.Settings.Availability 'available'}}{{else if eq $srv.Settings.Availability 'backup'}}backup{{else if eq $srv.Settings.Availability 'unavailable'}}down{{end}}; {{end}} } server { {{if eq .Balancer.Settings.Protocol 'http'}} listen {{.Balancer.Settings.Port}}; {{else if eq .Balancer.Settings.Protocol 'https'}} listen {{.Balancer.Settings.Port}} ssl; {{end}} server_name {{.Balancer.Settings.Hostname}}; {{if eq .Balancer.Settings.Protocol 'https'}} ssl on; ssl_certificate {{.Dir}}/server.crt; ssl_certificate_key {{.Dir}}/server.key; {{end}} location / { proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; proxy_pass http://{{.Balancer.Id.Hex}}; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection 'upgrade'; } } `))

โหลดซ้ำ เปิดฟังก์ชันอื่นอยู่ โครงสร้าง Nginx ที่ทำให้ NGINX โหลดไฟล์คอนฟิกูเรชันซ้ำ กลไกที่ใช้ขึ้นอยู่กับวิธีการกำหนดค่า Loadcat โดยค่าเริ่มต้นจะถือว่า NGINX เป็นบริการ systemd ที่ทำงานเป็น nginx.service เช่นนั้น [sudo] systemd reload nginx.service จะทำงาน. อย่างไรก็ตามแทนที่จะเรียกใช้คำสั่งเชลล์จะสร้างการเชื่อมต่อกับ systemd ผ่าน D-Bus โดยใช้ไฟล์ แพ็คเกจ github.com/coreos/go-systemd/dbus .

GUI บนเว็บ

เมื่อนำส่วนประกอบเหล่านี้มาใช้แล้วเราจะรวมเข้ากับอินเทอร์เฟซผู้ใช้ Bootstrap แบบธรรมดา

คุณสมบัติการจัดสรรภาระงาน NGINX รวมอยู่ใน GUI ที่เรียบง่าย ทวีต

สำหรับฟังก์ชันพื้นฐานเหล่านี้ตัวจัดการเส้นทาง GET และ POST ง่ายๆเพียงไม่กี่ตัวก็เพียงพอแล้ว:

GET /balancers GET /balancers/new POST /balancers/new GET /balancers/{id} GET /balancers/{id}/edit POST /balancers/{id}/edit GET /balancers/{id}/servers/new POST /balancers/{id}/servers/new GET /servers/{id} GET /servers/{id}/edit POST /servers/{id}/edit

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

แต่ละฟังก์ชันตัวจัดการเป็นกิจวัตรที่:

• ดึงข้อมูลจากที่เก็บข้อมูลและตอบกลับด้วยเทมเพลตที่แสดงผล (โดยใช้ข้อมูลที่ดึงมา)
• แยกวิเคราะห์ข้อมูลในรูปแบบที่เข้ามาทำการเปลี่ยนแปลงที่จำเป็นในพื้นที่เก็บข้อมูลและใช้ package feline เพื่อสร้างไฟล์การกำหนดค่า NGINX ใหม่

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

func ServeServerNewForm(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) bal, _ := data.GetBalancer(bson.ObjectIdHex(vars['id'])) TplServerNewForm.Execute(w, struct { Balancer *data.Balancer }{ Balancer: bal, }) } func HandleServerCreate(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) bal, _ := data.GetBalancer(bson.ObjectIdHex(vars['id'])) r.ParseForm() body := struct { Label string `schema:'label'` Settings struct { Address string `schema:'address'` } `schema:'settings'` }{} schema.NewDecoder().Decode(&body, r.PostForm) srv := data.Server{} srv.BalancerId = bal.Id srv.Label = body.Label srv.Settings.Address = body.Settings.Address srv.Put() feline.Commit(bal) http.Redirect(w, r, '/servers/'+srv.Id.Hex()+'/edit', http.StatusSeeOther) }

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

HandleServerCreate ฟังก์ชันอื่นที่ไม่ใช่จะแยกวิเคราะห์ข้อมูล POST ที่เข้ามาจากร่างกายเป็นไฟล์ โครงสร้าง และใช้ข้อมูลเหล่านั้นเพื่อสร้างอินสแตนซ์และคงอยู่ใหม่ โครงสร้างเซิร์ฟเวอร์ ใน datastore ก่อนที่จะใช้ package feline เพื่อสร้างไฟล์คอนฟิกูเรชัน NGINX ใหม่สำหรับบาลานเซอร์

เทมเพลตของเพจทั้งหมดจะถูกเก็บไว้ในไฟล์“ ui / templates.go” และไฟล์ HTML ของเทมเพลตที่เกี่ยวข้องสามารถพบได้ในไดเร็กทอรี“ ui / template”

ฉันจะทำอะไรกับ node.js . ได้บ้าง

ลองใช้งาน

การปรับใช้ Loadcat กับเซิร์ฟเวอร์ระยะไกลหรือแม้กระทั่งในสภาพแวดล้อมภายในเครื่องของคุณนั้นง่ายมาก หากคุณใช้ Linux (64 บิต) คุณสามารถดึงไฟล์เก็บถาวรที่มีไบนารี Loadcat ที่สร้างไว้ล่วงหน้าจากที่เก็บ ส่วนเผยแพร่ . หากคุณรู้สึกหวาดเสียวเล็กน้อยคุณสามารถโคลนที่เก็บและรวบรวมโค้ดด้วยตัวเอง แม้ว่าประสบการณ์ในกรณีนั้นอาจจะเล็กน้อย น่าผิดหวัง เนื่องจากการรวบรวมโปรแกรม Go ไม่ใช่เรื่องท้าทาย และในกรณีที่คุณใช้ Arch Linux แสดงว่าคุณโชคดี! มีการสร้างแพ็คเกจสำหรับแจกจ่ายเพื่อความสะดวก เพียงแค่ ดาวน์โหลดได้ และติดตั้งโดยใช้ตัวจัดการแพ็คเกจของคุณ ขั้นตอนที่เกี่ยวข้องมีรายละเอียดเพิ่มเติมในโครงการ ไฟล์ README.md .

เมื่อคุณกำหนดค่าและเรียกใช้ Loadcat แล้วให้ชี้เว็บเบราว์เซอร์ของคุณไปที่“ http: // localhost: 26590” (สมมติว่ากำลังทำงานในเครื่องและฟังบนพอร์ต 26590) จากนั้นสร้างบาลานเซอร์สร้างเซิร์ฟเวอร์สองเครื่องตรวจสอบให้แน่ใจว่ามีบางสิ่งกำลังฟังอยู่บนพอร์ตที่กำหนดเหล่านั้นและคุณควรมีคำขอขาเข้าโหลดบาลานซ์ของ NGINX ระหว่างเซิร์ฟเวอร์ที่รันเหล่านั้น

อะไรต่อไป?

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

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