กงสุล - คู่มือฉบับย่อ

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

• Service Discovery - การใช้ DNS หรือ HTTP ทำให้แอปพลิเคชันสามารถค้นหาบริการที่ขึ้นอยู่กับได้อย่างง่ายดาย

• Health Check Status- สามารถตรวจสุขภาพกี่ครั้งก็ได้ มันถูกใช้โดยคอมโพเนนต์การค้นหาบริการเพื่อกำหนดเส้นทางการรับส่งข้อมูลออกจากโฮสต์ที่ไม่แข็งแรง

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

• Multi Datacenter Deployment- กงสุลสนับสนุนศูนย์ข้อมูลหลายแห่ง ใช้สำหรับการสร้างเลเยอร์นามธรรมเพิ่มเติมเพื่อขยายไปยังหลายภูมิภาค

• Web UI - กงสุลให้บริการอินเทอร์เฟซทางเว็บที่สวยงามแก่ผู้ใช้ซึ่งสามารถใช้งานง่ายและจัดการคุณลักษณะทั้งหมดในกงสุล

การค้นพบบริการ

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

เปรียบเทียบกับ Etcd และ Zookeeper

เมื่อเราดูเครื่องมือค้นหาบริการอื่น ๆ ในโดเมนนี้เรามีตัวเลือกยอดนิยมสองตัวเลือก ผู้เล่นรายใหญ่บางรายในอุตสาหกรรมซอฟต์แวร์เคยใช้มาแล้ว เครื่องมือเหล่านี้คือEtcd และ Zookeeper.

ให้เราพิจารณาตารางต่อไปนี้เพื่อเปรียบเทียบลักษณะต่างๆของแต่ละเครื่องมือ นอกจากนี้เรายังจะเข้าใจสิ่งที่แต่ละคนใช้ภายใน

คุณสมบัติ	กงสุล	Etcd	Zoo Keeper
หน้าจอผู้ใช้	มีจำหน่าย
RPC	มีจำหน่าย	มีจำหน่าย
ตรวจสุขภาพ	HTTP API	HTTP API	TCP
ค่าคีย์	3 โหมดความสอดคล้อง	ความสม่ำเสมอที่ดี	ความสม่ำเสมอที่แข็งแกร่ง
ระบบโทเค็น	มีจำหน่าย
ภาษา	โกลัง	โกลัง	Java

กงสุล - สมาชิกและตัวแทน

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

ตัวแทนกงสุลเป็นกระบวนการหลักของกงสุล ตัวแทนจะเก็บรักษาข้อมูลการเป็นสมาชิกลงทะเบียนบริการรันเช็คตอบสนองต่อการสอบถาม ฯลฯ ตัวแทนใด ๆ สามารถรันในโหมดใดโหมดหนึ่งจากสองโหมด:Client หรือ Server. สองโหมดนี้สามารถใช้ได้ตามบทบาทที่ตัดสินใจเมื่อใช้กงสุล ตัวแทนกงสุลช่วยเหลือโดยการให้ข้อมูลแก่เราตามรายการด้านล่าง

• Node name - นี่คือชื่อโฮสต์ของเครื่อง

• Datacenter- ศูนย์ข้อมูลที่เอเจนต์ถูกกำหนดค่าให้รัน แต่ละโหนดต้องได้รับการกำหนดค่าเพื่อรายงานไปยังศูนย์ข้อมูล

• Server- ระบุว่าเอเจนต์กำลังทำงานในโหมดเซิร์ฟเวอร์หรือไคลเอนต์ โหนดเซิร์ฟเวอร์มีส่วนร่วมในโควรัมฉันทามติการจัดเก็บสถานะคลัสเตอร์และการจัดการคิวรี

• Client Addr- เป็นที่อยู่ที่ใช้สำหรับอินเทอร์เฟซไคลเอ็นต์โดยตัวแทน รวมถึงพอร์ตสำหรับอินเตอร์เฟส HTTP, DNS และ RPC

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

ในบทต่อไปเราจะทำความเข้าใจกับสถาปัตยกรรมสำหรับกงสุล

แผนภาพสถาปัตยกรรมสำหรับกงสุลที่ทำงานในศูนย์ข้อมูลหนึ่งสามารถอธิบายได้ดีที่สุดดังที่แสดงด้านล่าง -

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

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

อัลกอริทึมแพ

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

ก Raft Clusterประกอบด้วยเซิร์ฟเวอร์หลายเครื่องโดยปกติจะอยู่ในจำนวนคี่ ตัวอย่างเช่นหากเรามีเซิร์ฟเวอร์ห้าเครื่องระบบจะยอมให้เกิดความล้มเหลวสองครั้ง ในช่วงเวลาใดก็ตามแต่ละเซิร์ฟเวอร์อยู่ในหนึ่งในสามสถานะ:Leader, Follower, หรือ Candidate. ในการทำงานปกติมีผู้นำคนเดียวและเซิร์ฟเวอร์อื่น ๆ ทั้งหมดเป็นผู้ติดตาม ผู้ติดตามเหล่านี้อยู่ในสถานะเฉยเมยกล่าวคือพวกเขาไม่ออกคำขอด้วยตนเอง แต่เพียงตอบสนองต่อคำร้องขอจากผู้นำและผู้สมัคร

ภาพประกอบต่อไปนี้อธิบายถึงโมเดลเวิร์กโฟลว์ที่ใช้อัลกอริทึมแพทำงาน -

ข้อมูลมูลค่าหลัก

ตั้งแต่รุ่น 0.7.1 ของกงสุลได้มีการแนะนำข้อมูลคีย์ค่าแยกต่างหาก คำสั่ง KV ใช้เพื่อโต้ตอบกับที่เก็บคีย์ - ค่าของกงสุลผ่านทางบรรทัดคำสั่ง มันแสดงคำสั่งระดับบนสุดสำหรับInserting, Updating, Reading และ Deletingจากร้านค้า ในการรับที่เก็บอ็อบเจ็กต์คีย์ / ค่าเราเรียกวิธี KV สำหรับไคลเอ็นต์กงสุล -

kv := consul.KV()

KVPair Structureใช้เพื่อแสดงรายการคีย์ / ค่าเดียว เราสามารถดูโครงสร้างของ Consul KV Pair ได้ในโปรแกรมต่อไปนี้

type KVPair struct {
   Key string
   CreateIndex uint64
   ModifyIndex uint64
   LockIndex uint64
   Flags uint64
   Value []byte
   Session string
}

ที่นี่โครงสร้างต่างๆที่กล่าวถึงในโค้ดข้างต้นสามารถกำหนดได้ดังนี้ -

• Key- เป็นชื่อ URL แบบทับ ตัวอย่างเช่น - sites / 1 / domain

• CreateIndex - หมายเลขดัชนีกำหนดเมื่อสร้างคีย์ครั้งแรก

• ModifyIndex - หมายเลขดัชนีกำหนดเมื่อคีย์ได้รับการอัปเดตครั้งล่าสุด

• LockIndex - หมายเลขดัชนีที่สร้างขึ้นเมื่อได้รับการล็อกใหม่ในรายการคีย์ / ค่า

• Flags - แอปสามารถใช้เพื่อตั้งค่าที่กำหนดเองได้

• Value - เป็นอาร์เรย์ไบต์สูงสุด 512kb

• Session - สามารถตั้งค่าได้หลังจากสร้างวัตถุเซสชัน

ประเภทของโปรโตคอล

มีโปรโตคอลสองประเภทในกงสุลซึ่งเรียกว่า -

• Consensus Protocol และ
• พิธีสารซุบซิบ

ตอนนี้ให้เราทำความเข้าใจโดยละเอียด

พิธีสารฉันทามติ

Consensus protocol ใช้โดย Consul เพื่อให้ความสอดคล้องตามที่อธิบายโดย CAP Theorem โปรโตคอลนี้ใช้ Raft Algorithm เมื่อใช้โปรโตคอล Consensus Raft Algorithm จะถูกใช้โดยที่โหนดแพจะอยู่ในสถานะใดสถานะหนึ่งในสามสถานะเสมอ: Follower, Candidate หรือ Leader

พิธีสารซุบซิบ

สามารถใช้โพรโทคอลซุบซิบเพื่อจัดการการเป็นสมาชิกส่งและรับข้อความข้ามคลัสเตอร์ ในกงสุลการใช้โปรโตคอลนินทาเกิดขึ้นได้สองวิธีคือWAN (Wireless Area Network) และ LAN(เครือข่ายท้องถิ่น). มีไลบรารีที่รู้จักสามไลบรารีซึ่งสามารถใช้อัลกอริทึม Gossip เพื่อค้นหาโหนดในเครือข่ายเพียร์ทูเพียร์ -

• teknek-gossip - ทำงานร่วมกับ UDP และเขียนด้วย Java

• gossip-python - ใช้ TCP stack และสามารถแชร์ข้อมูลผ่านเครือข่ายที่สร้างขึ้นได้เช่นกัน

• Smudge - เขียนใน Go และใช้ UDP เพื่อแลกเปลี่ยนข้อมูลสถานะ

นอกจากนี้ยังมีการใช้โปรโตคอล Gossip เพื่อให้บรรลุและรักษาความสอดคล้องของฐานข้อมูลแบบกระจายหรือกับข้อมูลประเภทอื่น ๆ ในสถานะที่สอดคล้องกันการนับจำนวนโหนดในเครือข่ายที่ไม่ทราบขนาดการกระจายข่าวสารอย่างมีประสิทธิภาพการจัดระเบียบโหนด ฯลฯ

การเรียกขั้นตอนระยะไกล

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

ความงดงามที่แท้จริงของการใช้ RPC ในกงสุลคือช่วยให้เราหลีกเลี่ยงปัญหาเวลาแฝงซึ่งเครื่องมือบริการค้นหาส่วนใหญ่มีมาก่อนแล้ว ก่อน RPC กงสุลเคยมีเพียงTCP และ UDPตามการเชื่อมต่อซึ่งดีกับระบบส่วนใหญ่ แต่ไม่ใช่ในกรณีของระบบกระจาย RPC แก้ปัญหาดังกล่าวโดยลดระยะเวลาในการถ่ายโอนข้อมูลแพ็กเก็ตจากที่หนึ่งไปยังอีกที่หนึ่ง ในส่วนนี้GRPC by Google เป็นเครื่องมือที่ยอดเยี่ยมในการมองไปข้างหน้าในกรณีที่ต้องการสังเกตเกณฑ์มาตรฐานและเปรียบเทียบประสิทธิภาพ

เพื่อวัตถุประสงค์ในการสาธิตเราจะใช้ตัวแทนกงสุลในโหมดผู้พัฒนาโดยใช้โหมด -dev สำหรับการตั้งค่าเครื่องในประเทศเราจะทำการตั้งค่ากงสุลระบบเดียวPlease do not use this single node consul cluster in your production. ดังที่ Hashicorp กล่าวไว้แล้วในกรณีสถานการณ์ของคลัสเตอร์กงสุลโหนดเดียวthe data loss is inevitable.

ติดตั้งกงสุล

สามารถติดตั้งกงสุลผ่านหน้าดาวน์โหลดที่www.consul.io/downloads.html

คุณสามารถแยกแพ็กเกจไบนารีในส่วนดาวน์โหลดของเครื่องของคุณ

$ cd Downloads $ chmod +x consul
$ sudo mv consul /usr/bin/

ตอนนี้ให้เราเริ่มใช้กงสุลโดยใช้ -dev flag.

$ consul agent -dev -data-dir=/tmp/consul

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ตอนนี้คุณสามารถตรวจสอบสมาชิกกงสุลของคุณได้โดยใช้คำสั่งต่อไปนี้

$ consul members

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

หากคุณต้องการเข้าร่วมโหนดอื่นกับโหนดนี้ -

$ consul join <Node 2> <Node 3>

หรือคุณสามารถรันคำสั่งต่อไปนี้บนโหนด 2 และ 3 -

$ consul join <Node 1>

การใช้ Command Line

สายการบังคับบัญชาของกงสุลประกอบด้วยตัวเลือกที่แตกต่างกันหลายตัวเลือกที่ใช้บ่อยที่สุดมีดังนี้ -

• agent - ซึ่งทำงานเป็นตัวแทนกงสุล

• configtest - เพื่อตรวจสอบไฟล์กำหนดค่า

• event - เพื่อเริ่มกิจกรรมใหม่

• exec - เพื่อดำเนินการคำสั่งบนโหนดกงสุล

• force-leave - บังคับให้สมาชิกของคลัสเตอร์ออกจากคลัสเตอร์

• info - ให้ข้อมูลการดีบักสำหรับตัวดำเนินการ

• join - เพื่อให้ตัวแทนกงสุลเข้าร่วมคลัสเตอร์

• keygen - เพื่อสร้างคีย์เข้ารหัสใหม่

• keyring - เพื่อจัดการคีย์การเข้ารหัสชั้นซุบซิบ

• kv - เพื่อโต้ตอบกับที่เก็บคีย์ - ค่า

• leave - ให้ออกจากคลัสเตอร์กงสุลและปิดโดยไม่มีการบังคับ

• lock - เพื่อดำเนินการคำสั่งเพื่อกดล็อค

• maint - เพื่อควบคุมโหนดหรือโหมดการบำรุงรักษาบริการ

• members - แสดงรายชื่อสมาชิกของคลัสเตอร์กงสุล

• monitor - สตรีมบันทึกจากตัวแทนกงสุล

• operator - จัดเตรียมกลุ่มเครื่องมือสำหรับเจ้าหน้าที่กงสุล

• reload - ทริกเกอร์เอเจนต์ให้โหลดไฟล์คอนฟิกูเรชันซ้ำ

• rtt - ประมาณการเวลาเดินทางไปกลับของเครือข่ายระหว่างโหนด

• snapshot - บันทึกกู้คืนและตรวจสอบภาพรวมของสถานะเซิร์ฟเวอร์กงสุล

• version - เพื่อพิมพ์กงสุลฉบับปัจจุบัน

• watch - ระวังการเปลี่ยนแปลงในกงสุล

แม่แบบกงสุล

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

แม่แบบกงสุลจะถูกสร้างขึ้นที่ /tmp/<name-of-file>.conf.tmpfl. ภาษาที่ใช้เขียนเทมเพลตตามHashicorp Configuration Language (HCL).

คุณสามารถดาวน์โหลดแม่แบบกงสุลได้จากหน้านี้

ลองใช้งานโดยใช้คำสั่งต่อไปนี้ -

$ ./consul-template -h

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

หากคุณต้องการย้ายไบนารีนี้ไปยังพื้นที่ที่โดดเด่นมากขึ้นเพื่อให้ผู้ใช้สามารถใช้งานได้ทุกครั้ง คุณสามารถพิมพ์คำสั่งต่อไปนี้ -

$ chmod +x consul-template $ sudo mv consul-template /usr/share/bin/

เพื่อวัตถุประสงค์ในการสาธิตเราจะใช้การกำหนดค่าตัวอย่างของ nginxเพื่อใช้เป็นบริการของเรา คุณสามารถทดลองใช้การสาธิตเพิ่มเติมได้ที่https://github.com/hashicorp/consul-template/tree/master/examples หรือเขียนเทมเพลตของคุณเองดีกว่า

$ vim /tmp/nginx.conf.ctmpl

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ไฟล์กำหนดค่าอาจมีลักษณะดังนี้ -

{{range services}} {{$name := .Name}} {{$service := service .Name}} upstream {{$name}} {
   zone upstream-{{$name}} 64k; {{range $service}}server {{.Address}}:{{.Port}} max_fails = 3 fail_timeout = 60
   weight = 1;
   {{else}}server 127.0.0.1:65535; # force a 502{{end}}
} {{end}}

server {
   listen 80 default_server;
   location / {
      root /usr/share/nginx/html/;
      index index.html;
   }
   location /stub_status {
      stub_status;
   }
   {{range services}} {{$name := .Name}} location /{{$name}} {
      proxy_pass http://{{$name}};
   }
   {{end}}
}

ขณะนี้ใช้ไฟล์ไบนารีแม่แบบกงสุลโปรดเรียกใช้คำสั่งต่อไปนี้ -

$ consul-template \
 -template = "/tmp/nginx.conf.ctmpl:/etc/nginx/conf.d/default.conf"

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

$ cat /etc/nginx/conf.d/default.conf

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ในบทนี้เราจะทำความเข้าใจว่า Microservices ทำงานร่วมกับกงสุลอย่างไร นอกจากนี้เรายังจะได้เรียนรู้ว่าส่วนประกอบต่อไปนี้มีผลต่อกงสุลอย่างไร

• ใช้นักเทียบท่า
• ผู้ลงทะเบียนอาคารสำหรับการค้นพบบริการ
• ใช้ rkt และ Nomad

ตอนนี้ให้เราคุยรายละเอียดแต่ละเรื่องเหล่านี้

ใช้ Docker

ก่อนเริ่ม please do not use this setup in productionเนื่องจากใช้เพื่อการสาธิตเท่านั้น Docker เป็นบริการที่ใช้คอนเทนเนอร์ซึ่งเราสามารถปรับใช้แอปพลิเคชันของเราได้อย่างง่ายดาย สำหรับการใช้งานกงสุลเราจะใช้ภาพที่ลิงค์ต่อไปนี้ –0

https://hub.docker.com/r/progrium/consul/.

ระบบของคุณมีการติดตั้ง Docker และกำหนดค่าไว้อย่างเหมาะสม ให้เราลองดึงภาพจาก Docker hub โดยเรียกใช้คำสั่งต่อไปนี้ -

$ docker pull progrium/consul

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

เรากำลังจะเผยแพร่อินเทอร์เฟซบางส่วนกับพอร์ตของพวกเขา (โดยใช้ตัวเลือก -p บน Docker) ในลักษณะต่อไปนี้

• 8400 (RPC)
• 8500 (HTTP)
• 8600 (DNS)

ตามการดึงเราจะตั้งชื่อของชื่อโฮสต์เป็น node1คุณสามารถเปลี่ยนเป็นอะไรก็ได้ที่คุณต้องการโดยใช้ไฟล์ -h flag ด้วยชื่อโฮสต์ของคุณเองตามที่แสดงด้านล่าง

$ docker run -p 8400:8400 -p 8500:8500 -p 8600:53/udp -h node1 progrium/consul
-server -bootstrap

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

คุณยังสามารถเปิดใช้งานโหมด UI สำหรับกงสุลโดยใช้ -

$ docker run -p 8400:8400 -p 8500:8500 -p 8600:53/udp -h node1 progrium/consul
-server -bootstrap -ui-dir /ui

คุณสามารถตรวจสอบผลลัพธ์ตาม UI บน http://localhost:8500. ภาพหน้าจอต่อไปนี้ช่วยให้คุณมีความคิดที่ดีขึ้นเกี่ยวกับเอาต์พุตที่ใช้ UI

สำหรับการใช้กงสุลบนคอนเทนเนอร์นักเทียบท่าต่างๆบนโหนดต่างๆเราสามารถรันคำสั่งต่อไปนี้บนโหนดต่างๆ -

บน Node1

$ docker run -d --name node1 -h node1 progrium/consul -server -bootstrap-expect 3

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

ก่อนที่จะดำเนินการต่อไปเราจำเป็นต้องได้รับ IP ภายในของคอนเทนเนอร์โดยการตรวจสอบคอนเทนเนอร์ สำหรับการใช้งานของเราวัตถุประสงค์ของกรณีเราจะประกาศ$ JOIN_IP.

$ JOIN_IP = "$(docker inspect -f '{{.NetworkSettings.IPAddress}}' node1)"

บน Node2

ดังนั้นให้เราเริ่ม Node2 และบอกให้เข้าร่วม Node1 โดยใช้ตัวแปรที่ประกาศในโปรแกรมที่ให้ไว้ด้านบน

$docker run -d --name node2 -h node2 progrium/consul -server -join $JOIN_IP

บน Node3

$ docker run -d --name node3 -h node3 progrium/consul -server -join $JOIN_IP

ผู้ลงทะเบียนอาคารสำหรับการค้นพบบริการ

ผู้ลงทะเบียนจะลงทะเบียนและยกเลิกการลงทะเบียนบริการสำหรับคอนเทนเนอร์ Docker โดยอัตโนมัติโดยการตรวจสอบคอนเทนเนอร์ในขณะที่ออนไลน์ ผู้ลงทะเบียนที่เรากำลังจะใช้ในปัจจุบันสนับสนุนการลงทะเบียนบริการแบบเสียบได้ซึ่งในปัจจุบันรวมถึงConsul, Etcd และ SkyDNS2. ขอแนะนำให้ใช้ Registrator เมื่อเราโต้ตอบกับบริการต่างๆผ่านเครือข่าย

$ docker pull gliderlabs/registrator:latest

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

$ docker run -d \
--name = registrator \
--net = host \
--volume = /var/run/docker.sock:/tmp/docker.sock \
gliderlabs/registrator:latest \
 consul://localhost:8500

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ผลลัพธ์ที่คุณได้รับคือ ID ของ Docker Container ที่คุณเพิ่งเริ่มต้น คุณสามารถตรวจสอบว่าคอนเทนเนอร์กำลังทำงานอยู่หรือไม่โดยใช้คำสั่ง -

$ docker ps -a

ผลลัพธ์ของเขาจะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

คุณยังสามารถดูบันทึกของ Registrator ได้โดยใช้คำสั่งต่อไปนี้

$ docker logs registrator

ใช้ rkt และ Nomad

rkt เป็นบริการที่ใช้คอนเทนเนอร์อื่นซึ่งคุณสามารถใช้ได้ในสภาพแวดล้อมของคุณ มันถูกสร้างขึ้นโดยCoreOS. เหตุผลหลักในการสร้าง rkt คือการปรับปรุงความปลอดภัยซึ่งเป็นหนึ่งในปัญหาวิกฤตสำหรับ Docker เมื่อมันยังอยู่ในการพัฒนาในปี 2013-14

สำหรับกงสุลเราสามารถใช้ Rkt Registrator เพื่อทำงานเกี่ยวกับการค้นพบบริการกับกงสุล โครงการ Registrator เฉพาะนี้ซึ่งครอบคลุมสำหรับ rkt อยู่ระหว่างการพัฒนาและอยู่ระหว่างการพัฒนาnot recommended for production level use.

คุณสามารถตรวจสอบว่า rkt ได้รับการติดตั้งหรือไม่โดยไปที่พา ธ และรันคำสั่งต่อไปนี้

$ ./rkt

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

สำหรับการทดลองใช้ rkt และกงสุลโปรดตรวจสอบ - https://github.com/r3boot/rkt-registrator.

Nomad Tool

หนึ่งในตัวเลือกที่นิยมใช้กันมากที่สุดคือ Nomad tool Nomad เป็นเครื่องมือสำหรับจัดการกลุ่มเครื่องจักรและเรียกใช้แอปพลิเคชันบนเครื่องเหล่านั้น มันคล้ายกับMesos หรือ Kubernetes. ตามค่าเริ่มต้น Nomad จะครอบคลุมไดรเวอร์ Docker และ rkt ภายในตัวมันเอง ดังนั้นหากคุณกำลังมองหาการติดตั้งตู้คอนเทนเนอร์ขนาดใหญ่กับกงสุล เร่ร่อนอาจเป็นทางออกที่ดี ตรวจสอบ -https://www.nomadproject.io/docs/drivers/rkt.html สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ Nomad

ในบทนี้เราจะพูดถึงวิธีการใช้ส่วนประกอบต่อไปนี้ในกงสุล

• bootstrapping อัตโนมัติ
• การบูตด้วยตนเอง
• ใช้ DNS Forwarding
• การแคช DNS

ตอนนี้ให้เราคุยรายละเอียดแต่ละเรื่องเหล่านี้

Bootstrapping อัตโนมัติ

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

$ sudo consul info

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

คำสั่งนี้จะแสดงการทำงานจริงของกงสุลใน real working scenarios. มันจะแสดง Raft Algorithm ที่ทำงานในกงสุล คำสั่ง bootstrapping อัตโนมัติสามารถแสดงได้โดยใช้คำสั่งต่อไปนี้ -

$ consul agent -server -data-dir = ”/tmp/consul” -bootstrap-expect 3

Automatic bootstrapping cannot be done in -dev mode.

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

การบูตด้วยตนเอง

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

In this case, we will assume that a 3-node consul cluster is to be built.

มีสองตัวเลือกในการบูตด้วยตนเอง

• การรันคำสั่งบน 2 โหนด: บนโหนด B และโหนด C คุณสามารถทำสิ่งต่อไปนี้ -

$ consul join <Node A Address>

• รันคำสั่งมากกว่า 1 โหนด -

$ consul join <Node B Address> <Node C Address>

ใช้ DNS Forwarding

DNS ให้บริการจาก port 53. การส่งต่อ DNS สามารถทำได้โดยใช้BIND, dnsmasq และ iptables. ตามค่าเริ่มต้นตัวแทนกงสุลจะรันเซิร์ฟเวอร์ DNS ที่รับฟังบนพอร์ต 8600 โดยการส่งคำขอ DNS ไปยังเซิร์ฟเวอร์ DNS ของตัวแทนกงสุลคุณจะได้รับที่อยู่ IP ของโหนดที่เรียกใช้บริการที่คุณสนใจ

อินเทอร์เฟซ Consul DNS ทำให้ข้อมูลพอร์ตสำหรับบริการพร้อมใช้งานผ่านทาง SRV records. หากไม่มีการเพิ่มตรรกะในรหัสของคุณเองโดยทั่วไปคุณจะถูก จำกัด เฉพาะข้อมูลที่อยู่ IP (เช่นบันทึก) ของบริการที่คุณกำลังค้นหา

ตัวเลือกที่ดีที่สุดคือการมีเซิร์ฟเวอร์ BIND หลายตัวที่แต่ละเซิร์ฟเวอร์เรียกใช้ตัวแทนกงสุลในพื้นที่ คำถามใด ๆ ที่ได้รับจากเซิร์ฟเวอร์ BIND จะถูกส่งต่อไปยัง Consul Agent DNS Server ในพื้นที่

ใช้ Bind

เราสามารถใช้ DNS Forwarding โดยใช้ฟังก์ชัน Bind สามารถทำได้โดยใช้คำสั่งต่อไปนี้

$ sudo apt-get install bind9 bind9utils bind9-doc

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ให้เราแก้ไขไฟล์ /etc/bind/named.conf ด้วยคำสั่งต่อไปนี้

$ sudo vim /etc/bind/named.conf

ในไฟล์โปรดเพิ่มบรรทัดต่อไปนี้ใต้บรรทัดสุดท้ายของรหัส

options {
   directory "/var/cache/bind";
   recursion yes;
   allow-query { localhost; };
   
   forwarders {
      8.8.8.8;
      8.8.4.4;
   };
   dnssec-enable no;
   dnssec-validation no;
   auth-nxdomain no; # conform to RFC1035
   listen-on-v6 { any; };
};
include "/etc/bind/consul.conf";

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

คุณสามารถใช้คำสั่ง Bind ต่อไปนี้เพื่อกำหนดค่ากงสุล

$ sudo vim /etc/bind/consul.conf

เพิ่มบรรทัดต่อไปนี้เมื่อคุณสร้างไฟล์ -

zone "consul" IN {
   type forward;
   forward only;
   forwarders { 127.0.0.1 port 8600; };
};

ตอนนี้คุณสามารถเริ่มเรียกใช้ตัวแทนกงสุลของคุณได้โดยใช้คำสั่งต่อไปนี้ (อย่าลืมรีสตาร์ทบริการ bind9 ด้วย)

$ sudo service bind9 restart $ consul agent -server -bootstrap-expect 1 -data-dir = /tmp/consul -configdir = [Path]

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

คุณสามารถเพิ่มข้อมูลต่อไปนี้ใน /etc/resolv.conf:

nameserver 127.0.0.1

การแคช DNS

Consul ให้บริการผลลัพธ์ DNS ทั้งหมดด้วยค่า '0 TTL' (Time to Live) สิ่งนี้ป้องกันการแคชใด ๆ อย่างไรก็ตามเนื่องจากค่า TTL จึงสามารถตั้งค่าให้สามารถแคชผลลัพธ์ DNS กับดาวน์สตรีมของกงสุลได้ ค่า TTL ที่สูงขึ้นจะลดจำนวนการค้นหาบนเซิร์ฟเวอร์ Consul และความเร็วในการค้นหาสำหรับไคลเอ็นต์โดยมีค่าใช้จ่ายสำหรับผลลัพธ์ที่ค้างมากขึ้น

เพื่อจุดประสงค์นี้เราจะใช้ DNS caching โดยใช้วิธีการด้านล่าง -

$ sudo apt-get install dnsmasq

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ตอนนี้เราสามารถกำหนดค่าได้ง่ายมาก -

$ echo "server = /consul/127.0.0.1#8600" > /etc/dnsmasq.d/10-consul

สิ่งที่เราทำต่อไปนี้คือการระบุว่าคำขอ DNS สำหรับบริการกงสุลซึ่งเซิร์ฟเวอร์ DNS จะจัดการที่ 127.0.0.1 บนพอร์ต 8600 เว้นแต่คุณจะเปลี่ยนค่าเริ่มต้นของกงสุลสิ่งนี้ควรได้ผล

ในกรณีปกติควรใช้คำสั่งต่อไปนี้

$ dig @127.0.0.1 -p 8600 web.service.consul

ด้วย Dnsmasqคุณควรใช้คำสั่งต่อไปนี้

$ dig web.service.consul

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ในบทนี้เราจะเรียนรู้วิธีการค้นหาโหนดด้วยฟังก์ชันต่อไปนี้ -

• ใช้ขุด
• ใช้คำสั่ง Monitor
• ใช้คำสั่ง Watch
• โดยการลงทะเบียนบริการภายนอก

ให้เราเข้าใจรายละเอียดของแต่ละฟังก์ชันเหล่านี้

ใช้ Dig

กงสุลรับฟัง 127.0.0.1:8600 สำหรับคำถาม DNS ในกงสุล วิธีพิจารณาว่าโหนดใดพร้อมใช้งานเพื่อให้บริการคือการใช้การตรวจสอบที่สามารถเป็นได้ -

• สคริปต์ที่ถูกเรียกใช้งานและส่งกลับไฟล์ nagios compliant code.

• การตรวจสอบ HTTP ที่ส่งคืนรหัสตอบกลับ HTTP

• การตรวจสอบ TCP ที่กำลังตรวจสอบว่าพอร์ตเปิดอยู่หรือไม่

คำสั่งทั่วไปสำหรับการทดลองใช้ dig คือ -

$ dig @127.0.0.1 -p <port> <service-name>.consul

ตอนนี้ให้เราลองใช้ตัวอย่าง dig คำสั่ง -

$ dig @127.0.0.1 -p 8600 web.service.consul

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

การใช้คำสั่ง Monitor

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

ให้เราลองใช้คำสั่งต่อไปนี้ -

$ consul monitor

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

คุณยังสามารถตั้งค่าคำสั่งมอนิเตอร์โดยใช้คำสั่งย่อยเช่น -log-level และ -rpc-address ตามค่าเริ่มต้นที่อยู่ของ RPC คือ 127.0.0.1:8400 สำหรับข้อมูลเพิ่มเติมคลิกที่นี่

การใช้คำสั่ง Watch

คำสั่งนี้มีกลไกในการเฝ้าดูการเปลี่ยนแปลงในรายการโหนดสมาชิกบริการค่าคีย์ ฯลฯ นอกจากนี้ยังเรียกใช้กระบวนการที่มีค่าล่าสุดของมุมมอง หากไม่ได้ระบุกระบวนการค่าปัจจุบันจะถูกประมวลผลเป็นSTDOUTซึ่งอาจเป็นวิธีที่มีประโยชน์ในการตรวจสอบข้อมูลในกงสุล คำสั่ง Consul Watch Command มีตัวเลือกต่างๆมากมายดังที่แสดงในภาพหน้าจอต่อไปนี้ -

ให้เราลองสาธิตด้วย -type = service ดังแสดงในคำสั่งต่อไปนี้

$ consul watch -type = service -service = consul

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อนี้คุณสามารถคลิกที่นี่

โดยการลงทะเบียนบริการภายนอก

เมื่อลงทะเบียนแล้วอินเทอร์เฟซ DNS จะสามารถส่งคืน "A Records" หรือ CNAME Records ที่เหมาะสมสำหรับบริการ ให้เราลงทะเบียนบริการภายนอกเช่น Amazon ตามที่แสดงในบล็อกรหัสต่อไปนี้และภาพหน้าจอด้วย

$ sudo curl -X PUT -d '{"Datacenter": "dc1", "Node": "amazon",
"Address": "www.amazon.com",
"Service": {"Service": "shop", "Port": 80}}'
http://127.0.0.1:8500/v1/catalog/register

คำสั่งดังกล่าวระบุบริการที่เรียกว่าร้านค้า โหนดนี้เรียกว่า amazon โดยมี URL อยู่ที่www.amazon.comบนพอร์ต 80 ให้เราตรวจสอบผลลัพธ์ในกงสุลเพื่อให้แน่ใจว่าเราได้ติดตั้งบริการนี้อย่างถูกต้อง สำหรับสิ่งนี้โปรดเปิดหน้าต่างเบราว์เซอร์ที่ localhost: 8500

ในการลบบริการเราสามารถใช้คำสั่งต่อไปนี้

$ curl -X PUT -d '{"Datacenter": "dc1", "Node": "amazon"}'
http://127.0.0.1:8500/v1/catalog/deregister

ให้เราตรวจสอบ UI ตามที่แสดงในภาพหน้าจอต่อไปนี้

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

• คลัสเตอร์เดียวล้มเหลว
• การทดสอบ Jepsen
• หลายคลัสเตอร์ล้มเหลว
• การถ่ายภาพ

ให้เราเข้าใจโดยละเอียดแต่ละข้อ

คลัสเตอร์เดียวล้มเหลว

ในคลัสเตอร์เดียวล้มเหลวคลัสเตอร์ที่อยู่ในดาต้าเซ็นเตอร์แห่งใดแห่งหนึ่งเริ่มล้มเหลว ในทุกสถานการณ์สิ่งสำคัญคือต้องตรวจสอบให้แน่ใจว่าในกรณีที่เกิดความล้มเหลวระบบจะไม่สามารถป้องกันได้เท่านั้น แต่ยังต้องมีการสำรองข้อมูลที่สามารถพึ่งพาได้ด้วย เพื่อป้องกันเหตุการณ์ Consul Failover เราจะใช้สิ่งที่เรียกว่า Consul-alerts โครงการหลักได้ที่ -https://github.com/AcalephStorage/consul-alerts.

Consul-alerts เป็นภูตที่พร้อมใช้งานสำหรับการส่งการแจ้งเตือนและการแจ้งเตือนตามการตรวจสุขภาพของกงสุล โปรเจ็กต์นี้รัน daemon และ API ที่ localhost: 9000 และเชื่อมต่อกับตัวแทนกงสุลโลคัล (localhost: 8500) กับดาต้าเซ็นเตอร์เริ่มต้น (dc1)

มีสองวิธีในการเริ่มต้นโครงการ วิธีแรกคือการติดตั้งผ่านGO. สำหรับผู้ใช้ที่ติดตั้งและกำหนดค่า GO สามารถทำตามขั้นตอนด้านล่าง -

$ go get github.com/AcalephStorage/consul-alerts $ go install
$ consul-alerts start

คำสั่งสุดท้ายสามารถใช้เพื่อลบล้างพอร์ตดีฟอลต์สำหรับ consul-alert, datacenter option, consul-acl token เป็นต้นนอกจากนี้ยังสามารถเขียนคำสั่งได้ตามที่ระบุด้านล่าง -

$ consul-alerts start --alert-addr = localhost:9000 --consul-addr = localhost:8500
--consul-dc = dc1 --consul-acl-token = ""

วิธีที่สองเกี่ยวข้องกับผู้ใช้ในการใช้ Docker ทั้งสองวิธีมีประโยชน์เท่าเทียมกันในสถานการณ์ต่างๆ สำหรับการใช้ Consul-alerts over Docker ให้เราดึงภาพจาก Docker Hub โดยใช้คำสั่งต่อไปนี้

$ docker pull acaleph/consul-alerts

ในวิธี Docker เราสามารถพิจารณาสามตัวเลือกต่อไปนี้ -

• ใช้ตัวแทนกงสุลที่สร้างขึ้นในตู้คอนเทนเนอร์เอง
• การใช้ Consul Agent ที่รันบน Docker Container อื่น
• การใช้การแจ้งเตือนกงสุลเพื่อเชื่อมโยงผ่านอินสแตนซ์กงสุลระยะไกล

ตอนนี้ให้เราคุยทั้งสองอย่างโดยละเอียด

ใช้ตัวแทนกงสุลที่สร้างขึ้นในตู้คอนเทนเนอร์เอง

ให้เราเริ่มตัวแทนกงสุลโดยใช้คำสั่งต่อไปนี้ -

$ docker run -ti \
   --rm -p 9000:9000 \
   --hostname consul-alerts \
   --name consul-alerts \  
   --entrypoint = /bin/consul \
   acaleph/consul-alerts \
   agent -data-dir /data -server -bootstrap -client = 0.0.0.0

ที่นี่เรากำลังลบล้างไฟล์ entrypoint สำหรับกงสุลตามที่กล่าวไว้ในธง --entrypoint. นอกจากนี้เรากำลังบูตเครื่องไคลเอนต์โดยกล่าวถึงพอร์ตที่ใช้โดยใช้-p flag, data directory /data โดยใช้แฟล็ก -data-dir และไคลเอนต์เป็น 0.0.0.0

ในหน้าต่างเทอร์มินัลใหม่ให้เราเริ่มตัวเลือกการแจ้งเตือนกงสุล

$ docker exec -ti consul-alerts /bin/consul-alerts start --alertaddr = 0.0.0.0:9000
--log-level = info --watch-events --watch-checks

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

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

การใช้ Consul Agent ที่รันบน Docker Container อื่น

ที่นี่คุณสามารถใช้อิมเมจกงสุลประเภทใดก็ได้เพื่อเรียกใช้บน Docker Container การใช้รูปภาพการแจ้งเตือนของกงสุลเราสามารถเชื่อมโยงคอนเทนเนอร์กงสุลกับคอนเทนเนอร์การแจ้งเตือนของกงสุลได้อย่างง่ายดาย ซึ่งทำได้โดยใช้ไฟล์--link flag.

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

$ docker run -ti \
   -p 9000:9000 \
   --hostname consul-alerts \
   --name consul-alerts \
   --link consul:consul \
   acaleph/consul-alerts start \
   --consul-addr=consul:8500 \
   --log-level = info --watch-events --watch-checks

การใช้การแจ้งเตือนกงสุลเพื่อเชื่อมโยงผ่านอินสแตนซ์กงสุลระยะไกล

ในที่นี้เราควรใช้คำสั่งต่อไปนี้เพื่อใช้ Consul-alerts เพื่อเชื่อมโยงผ่านอินสแตนซ์กงสุลระยะไกล

$ docker run -ti \
   -p 9000:9000 \
   --hostname consul-alerts \
   --name consul-alerts \
   acaleph/consul-alerts start \
   --consul-addr = remote-consul-server.domain.tdl:8500 \
   --log-level = info --watch-events --watch-checks

การทดสอบ Jepsen

Jespen เป็นเครื่องมือที่เขียนขึ้นเพื่อทดสอบความทนทานและระบบเครือข่ายบางส่วนในระบบใด ๆ จะทดสอบระบบโดยสร้างการดำเนินการแบบสุ่มบนระบบJepsen is written in Clojure. น่าเสียดายที่สำหรับการสาธิตการทดสอบ Jepsen จำเป็นต้องมีการสร้างคลัสเตอร์ในระดับใหญ่ด้วยระบบฐานข้อมูลและด้วยเหตุนี้จึงอยู่นอกเหนือขอบเขตที่จะกล่าวถึงในที่นี้

Jepsen ทำงานโดยตั้งค่าที่เก็บข้อมูลภายใต้การทดสอบบนโฮสต์ที่แตกต่างกันห้าโฮสต์ สร้างไคลเอนต์สำหรับที่เก็บข้อมูลที่อยู่ระหว่างการทดสอบชี้แต่ละโหนดห้าโหนดเพื่อส่งคำขอ นอกจากนี้ยังสร้างชุดไคลเอนต์พิเศษที่เรียกว่า“ Nemesis” ซึ่งสร้างความหายนะในคลัสเตอร์เช่นการตัดการเชื่อมโยงระหว่างโหนดโดยใช้iptables. จากนั้นจะดำเนินการร้องขอพร้อมกันกับโหนดต่าง ๆ ในขณะที่แบ่งพาร์ติชันและรักษาเครือข่ายสลับกัน

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการทดสอบ Jepsen ตรวจสอบที่นี่

หลายคลัสเตอร์ล้มเหลว

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

เพื่อให้สิ่งนี้เกิดขึ้นเราจะพิจารณาโครงการที่ช่วยให้เราสามารถจำลองกงสุลจากคลัสเตอร์เดียวเป็นหลายคลัสเตอร์ โครงการนี้ให้วิธีการจำลองคู่ K / V กับศูนย์ข้อมูล Consul หลายศูนย์โดยใช้ Consul-replicate daemon คุณสามารถดูโครงการ Hashicorp นี้ได้ที่ -https://github.com/hashicorp/consul-replicate. ข้อกำหนดเบื้องต้นบางประการสำหรับการทดลองใช้โครงการนี้ ได้แก่ -

• Golang
• Docker
• Consul
• Git

ให้เราเริ่มต้นด้วยคำสั่งต่อไปนี้ -

Note - ก่อนรันคำสั่งต่อไปนี้โปรดตรวจสอบว่าคุณได้ติดตั้งและกำหนดค่า Git อย่างถูกต้องบนเครื่องของคุณ

$ git clone - https://github.com/hashicorp/consul-replicate.git

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

$ cd consul-replicate $ make

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

หากคุณประสบปัญหาในการสร้างไบนารีคุณสามารถลองดึงอิมเมจ Docker ด้วยตนเองโดยใช้คำสั่งต่อไปนี้ -

$ docker pull library/golang:1.7.4

คำสั่งดังกล่าวข้างต้นจะสร้าง bin / consul-replicate ซึ่งสามารถเรียกใช้เป็นไบนารีได้ ตารางต่อไปนี้แสดงรายการคำสั่งย่อยทั้งหมดที่ครอบคลุม -

ตัวเลือก	คำอธิบาย
รับรองความถูกต้อง	ชื่อผู้ใช้การพิสูจน์ตัวตนพื้นฐาน (และรหัสผ่านเสริม) คั่นด้วยเครื่องหมายทวิภาค ไม่มีค่าเริ่มต้น
กงสุล*	ตำแหน่งของอินสแตนซ์กงสุลที่จะสอบถาม (อาจเป็นที่อยู่ IP หรือ FQDN) พร้อมพอร์ต
สูงสุดค้าง	ความเก่าสูงสุดของแบบสอบถาม หากระบุไว้ Consule จะแจกจ่ายงานระหว่างเซิร์ฟเวอร์ทั้งหมดแทนที่จะเป็นเพียงผู้นำ ค่าเริ่มต้นคือ 0 (ไม่มี)
ssl	ใช้ HTTPS ขณะคุยกับกงสุล ต้องกำหนดคอนฟิกเซิร์ฟเวอร์ Consule เพื่อการเชื่อมต่อที่ปลอดภัยของเซิร์ฟเวอร์ ค่าเริ่มต้นเป็นเท็จ
ssl- ตรวจสอบ	ตรวจสอบใบรับรองเมื่อเชื่อมต่อผ่าน SSL สิ่งนี้จำเป็นต้องใช้ -ssl ค่าเริ่มต้นเป็นจริง
syslog	ส่งเอาต์พุตบันทึกไปยัง syslog (นอกเหนือจาก stdout และ stderr) ค่าเริ่มต้นเป็นเท็จ
syslog- สิ่งอำนวยความสะดวก	สิ่งอำนวยความสะดวกที่จะใช้เมื่อส่งไปยัง syslog สิ่งนี้ต้องใช้ -syslog ค่าเริ่มต้นคือ LOCAL
โทเค็น	โทเค็น Consul API ไม่มีค่าเริ่มต้น
คำนำหน้า*	คำนำหน้าแหล่งที่มารวมถึงคำนำหน้าปลายทางของตัวเลือกคั่นด้วยเครื่องหมายจุดคู่ (:). ตัวเลือกนี้เป็นส่วนเสริมและอาจระบุได้หลายครั้งสำหรับคำนำหน้าหลายคำที่จะทำซ้ำ
ไม่รวม	คำนำหน้าที่ไม่รวมระหว่างการจำลองแบบ ตัวเลือกนี้เป็นส่วนเสริมและอาจระบุได้หลายครั้งเพื่อยกเว้นคำนำหน้าหลายรายการ
รอ	minium (: maximum) เพื่อรอความเสถียรก่อนที่จะจำลองแบบคั่นด้วยเครื่องหมายจุดคู่ (:). หากไม่ใส่ค่าสูงสุดที่เป็นทางเลือกจะถือว่าเป็น 4x ของค่าต่ำสุดที่ต้องการ ไม่มีค่าเริ่มต้น
ลองอีกครั้ง	ระยะเวลาที่ต้องรอหาก Consule ส่งกลับข้อผิดพลาดเมื่อสื่อสารกับ API ค่าเริ่มต้นคือ 5 วินาที
config	พา ธ ไปยังไฟล์คอนฟิกูเรชันหรือไดเร็กทอรีของไฟล์คอนฟิกูเรชันบนดิสก์ซึ่งสัมพันธ์กับไดเร็กทอรีการทำงานปัจจุบัน ค่าที่ระบุบน CLI มีความสำคัญเหนือกว่าค่าที่ระบุในไฟล์คอนฟิกูเรชัน ไม่มีค่าเริ่มต้น
ระดับบันทึก	ระดับบันทึกสำหรับเอาต์พุต สิ่งนี้ใช้กับการบันทึก stdout / stderr ตลอดจนการบันทึก syslog (ถ้าเปิดใช้งาน) ค่าที่ถูกต้องคือ "debug", "info", "warn และ" err "ค่าเริ่มต้นคือ" warn "
ครั้งเดียว	รัน Consule Replicate หนึ่งครั้งและออก (ตรงข้ามกับพฤติกรรมเริ่มต้นของ daemon) (CLI เท่านั้น)
รุ่น	ข้อมูลเวอร์ชันเอาต์พุตและออก (CLI เท่านั้น)

การถ่ายภาพสแนปชอต

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

• บันทึกภาพรวมกงสุล
• ตัวแทนภาพรวมกงสุล
• ตรวจสอบภาพรวมกงสุล
• กู้คืนภาพรวมกงสุล

ให้เราเข้าใจโดยละเอียดแต่ละข้อ

บันทึกภาพรวมกงสุล

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

$ consul snapshot save <name-of-the-file>.snap

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

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

$ consul snapshot save -stale <name-of-file>.snap

ตัวแทนภาพรวมกงสุล

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

กงสุล Snapshot ตรวจสอบ

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

Note - โปรดจำไว้ว่าคำสั่งต่อไปนี้สามารถรันได้เฉพาะในไดเร็กทอรีที่บันทึกสแนปชอต

$ consul snapshot save <name-of-the-file>.snap

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

Consul Snapshot Restore

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

Note - โปรดจำไว้ว่าคำสั่งต่อไปนี้สามารถรันได้เฉพาะในไดเร็กทอรีที่บันทึกสแน็ปช็อต

$ consul snapshot restore <name-of-the-file>.snap

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

หากคุณกำลังทำงานกับกงสุลกับ AWS โครงการนี้อาจช่วยให้คุณประหยัดเวลาได้ - https://github.com/pshima/consul-snapshot.

ในบทนี้เราจะเรียนรู้วิธีการใช้ Consul UI (User Interface) และทำความเข้าใจส่วนประกอบที่สำคัญ

กงสุล UISetup

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

• ACL - ตั้งกฎเพื่อล็อคคลัสเตอร์ของคุณได้อย่างง่ายดาย

• Datacenter - ช่วยให้คุณสามารถจัดการศูนย์ข้อมูลและจัดการกับคลัสเตอร์ของคุณได้อย่างง่ายดาย

• Nodes - อัปเดตด่วนเกี่ยวกับโหนดที่คลัสเตอร์กงสุลใช้

ใช้ UI ของกงสุล

ในการใช้งาน UI ของกงสุลเราต้องติดตั้งแพ็คเกจ UI ที่ทีม Hashicorp จัดเตรียมไว้ในไซต์โครงการของกงสุล ดังนั้นให้เราลองดาวน์โหลดจากแหล่งที่มาและเริ่มใช้งาน โปรดใช้sudo นำหน้าทุกคำสั่งในกรณีที่ไฟล์ Permission Denied error จะแสดง

$ mkdir /opt/consul-ui
$ cd /opt/consul-ui $ wget https://releases.hashicorp.com/consul/0.7.2/consul_0.7.2_web_ui.zip
$ unzip consul_0.7.2_web_ui.zip $ rm consul_0.7.2_web_ui.zip

คุณสามารถดูผลลัพธ์ของ Consul UI โดยใช้คำสั่งต่อไปนี้เหนือตัวแทนใด ๆ

$ consul agent -dev -ui -data-dir /tmp/consul

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

ตามค่าเริ่มต้นคุณจะสังเกตเห็น UI ที่ http://localhost:8500/ui. ส่วน / ui เหมือนกับ HTTP API ของกงสุล

สำหรับการใช้ Consul UI บน Docker โปรดรันคำสั่งต่อไปนี้สำหรับอิมเมจ Docker (progrium / consul) -

$ docker run -p 8400:8400 -p 8500:8500 -p 8600:53/udp -h node1 progrium/consul
-server -bootstrap -ui-dir /ui

ผลลัพธ์จะเป็นดังที่แสดงในภาพหน้าจอต่อไปนี้

คุณสมบัติของ Consul UI

คุณสามารถเริ่มเรียกดู Consul UI ได้โดยดูที่คุณสมบัติบางอย่างเช่น -

• Nodes
• ACL
• Key/Value
• Settings
• Datacenter
• Services

ให้เราเข้าใจโดยละเอียดแต่ละข้อ

โหนด

การใช้งานพื้นฐานของ Nodes บน UI Dashboard สามารถสังเกตได้ดังแสดงในภาพหน้าจอต่อไปนี้

เมื่อคุณคลิกที่โหนดเฉพาะเช่น node1 ในกรณีของเราเราจะเห็นว่าข้อมูลบนโหนดนั้นสามารถมองเห็นได้ง่ายเช่น -

คุณสามารถยกเลิกการลงทะเบียนโหนดจากกงสุลได้ทุกเมื่อ ทำให้ง่ายต่อการจัดการโหนดจากมุมมองของคลัสเตอร์ระดับสูง

ACL (รายการควบคุมการเข้าถึง)

คุณสมบัติที่ดีที่สุดอย่างหนึ่งของกงสุลคือ Access Control Lists คุณสามารถเขียนการอนุญาตที่แตกต่างกันของคุณสำหรับคลัสเตอร์ต่างๆในศูนย์ข้อมูลต่างๆ วิธีที่ง่ายที่สุดวิธีหนึ่งในการเปิด ACL คือการเพิ่มไฟล์ json ใหม่ในไดเรกทอรีข้อมูลของกงสุล ในการเปิดใช้งานและอัปเดต ACL คุณสามารถเพิ่มโทเค็น ACL หลักในฟิลด์ในการตั้งค่าและรีเฟรชโดยใช้แท็บ ACL

สำหรับข้อมูลเพิ่มเติมโปรดตรวจสอบที่นี่

คีย์ / ค่า

ตัวเลือกมูลค่าหลักสำหรับกงสุลเป็นค่าเริ่มต้นใน UI ของกงสุล คุณสามารถสร้างรหัสของคุณเองโดยใช้ UI ของกงสุล นอกจากนี้ยังมีตัวเลือกในการสร้างโฟลเดอร์เพื่อจัดเก็บคีย์ของคุณ

การตั้งค่า

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

ศูนย์ข้อมูล

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

บริการ

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

ในบทนี้เราจะเรียนรู้วิธีใช้ Consul บน AWS (Amazon Web Services)

คุณสมบัติของ AWS

คุณสมบัติบางอย่างที่เป็นประโยชน์ในขณะใช้งาน Consul ใน AWS ได้แก่ -

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

หากคุณกำลังมองหาโซลูชันที่เราสามารถปรับใช้ Consul บน AWS กับ Docker ได้อย่างง่ายดาย ตรวจสอบลิงค์ต่อไปนี้ -https://github.com/dwmkerr/terraform-consul-cluster.

การปรับใช้ AWS

สำหรับการใช้ AWS เราสามารถเริ่มต้นด้วยการสร้าง VPC สำหรับมัน สำหรับการปรับใช้กงสุลใน AWS เราจะใช้เทมเพลตเริ่มต้นอย่างรวดเร็วตามที่ AWS Service ให้ไว้ เทมเพลตนี้สามารถพบได้ง่ายที่ -https://aws.amazon.com/quickstart/architecture/consul/.

สำหรับบทนี้เราถือว่าคุณรู้พื้นฐานของ AWS แล้ว เทมเพลต AWS CloudFormation จะสร้างส่วนประกอบต่อไปนี้ -

• ก VPC ด้วยเครือข่ายย่อยสาธารณะและส่วนตัวในสาม Availability Zone

• ก Seed Consul server และก Seed client พร้อมกับกลุ่มการปรับขนาดอัตโนมัติสองกลุ่ม

• คุณสามารถเลือกสร้างเซิร์ฟเวอร์ 3, 5 หรือ 7 เซิร์ฟเวอร์ จำนวนไคลเอ็นต์ถูกตั้งค่าเป็นสามโดยค่าเริ่มต้น แต่ผู้ใช้กำหนดค่าได้

• Dnsmasqซึ่งติดตั้งและกำหนดค่าสำหรับกงสุลเป็นส่วนหนึ่งของการติดตั้ง

• คลัสเตอร์กงสุลโดยใช้ bootstrap_expect ตัวเลือก

ดูภาพประกอบต่อไปนี้เพื่อทำความเข้าใจว่าส่วนประกอบต่างๆเชื่อมต่อกันอย่างไร

การใช้ AWS

โปรดตรวจสอบว่าคุณได้ลงชื่อเข้าใช้โครงสร้างพื้นฐาน AWS ของคุณโดยใช้เว็บคอนโซลแล้ว ตอนนี้โปรดใส่URLต่อไปนี้ลงในหน้าต่างเบราว์เซอร์ เมื่อคุณพิมพ์ URL และกด Enter เว็บไซต์ AWS จะเปิดขึ้น

สำหรับการสาธิตนี้เราจะเลือกปรับใช้ใน VPC ใหม่ (Virtual Private Cloud) คุณสามารถตรวจสอบการจัดการ VPC ของ AWS ได้ตลอดเวลาในลิงก์ต่อไปนี้ - https: // <awsregion> .console.aws.amazon.com / vpc / home สำหรับผู้ใช้ครั้งแรกภูมิภาคโดยค่าเริ่มต้นคือ West Oregon ในสหรัฐอเมริกา ดังนั้นคุณสามารถเยี่ยมชม URL ได้โดยตรงที่ - https: // us-west- 2.console.aws.amazon.com/vpc/home

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

เมื่อคลิกตัวเลือกที่อธิบายไว้ข้างต้นคุณจะเห็นว่าหน้าต่างเปิดขึ้นมาใหม่ซึ่งคล้ายกับที่แสดงด้านล่าง

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

ดังที่คุณเห็นว่ามีค่าและตัวเลือกต่างๆมากมายที่คุณสามารถกำหนดค่าได้ที่นี่ สำหรับการเปลี่ยนแปลงบางอย่างคุณสามารถเปลี่ยนชื่อได้ตามที่คุณเลือกโดยแทนที่ชื่อ HashiCorp-Consul โปรดอย่าลังเลที่จะเปลี่ยนตัวเลือกอื่น ๆ ตามความสะดวกของคุณ

ดังที่คุณเห็นด้านบนตัวเลือกต่างๆสามารถปรับแต่งได้ตามที่คุณเลือก ดังที่คุณเห็นในส่วนการตั้งค่ากงสุลประเภทอินสแตนซ์ Consul Cluster เริ่มต้นคือt2.medium. คุณสามารถเปลี่ยนเป็นอินสแตนซ์ที่คุณเลือกได้

Note - กรอกช่วงที่อนุญาตเป็น 0.0.0.0/0 สำหรับการอนุญาตที่อยู่ IP ใด ๆ

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

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

สำหรับตัวเลือกขั้นสูงเพิ่มเติมโปรดเลือก advanced tabซึ่งคุณสามารถเปิดใช้งาน Amazon SNS สำหรับ VPC ของคุณสำหรับการแจ้งเตือน โปรดดำเนินการต่อในตัวเลือกถัดไปเมื่อคุณกรอกรายละเอียดเรียบร้อยแล้ว

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

คุณสามารถตรวจสอบผลลัพธ์ได้ในส่วน CloudFormation Stack ของคอนโซลการจัดการ AWS ตามเอาต์พุต VPC คุณสามารถตรวจสอบได้ที่ส่วน VPC ของ AWS Console ดังที่แสดงในภาพหน้าจอด้านล่าง

หากคุณกำลังทดสอบเฉพาะแม่แบบกงสุลโปรดตรวจสอบให้แน่ใจว่าคุณได้ลบทรัพยากรที่คุณใช้แล้ว คุณสามารถทำได้อย่างง่ายดายโดยการลบ CloudFormation Stack ในส่วน CloudFormation และ VPC บนแดชบอร์ด VPC