การจัดการการกำหนดค่า: โทโพโลยีแบบพุชและแบบพุช

ระบบการจัดการการกำหนดค่า (CM) ที่เป็นที่ยอมรับมากขึ้นเช่น Puppet และ Chef ใช้วิธีการแบบดึง: ไคลเอนต์สำรวจต้นแบบหลักที่ส่วนกลางเป็นระยะสำหรับการปรับปรุง บางคนเสนอวิธีการที่ไม่เชี่ยวชาญเช่นกัน (เช่นเป็นแบบ push-based) แต่ระบุว่ามันไม่ใช่ 'สำหรับการผลิต' (Saltstack) หรือ 'scalable ที่น้อยลง' (Puppet) ระบบเดียวที่ฉันรู้ว่าเป็นแบบ push-based ตั้งแต่เริ่มต้นคือวิ่ง Ansible

อะไรคือข้อได้เปรียบในการปรับขนาดที่เฉพาะเจาะจงของระบบที่ใช้แรงดึง ทำไมมันจึงง่ายกว่าที่จะเพิ่ม pull-masters มากกว่า push-agent

ตัวอย่างเช่นagiletesting.blogspot.nlเขียน:

ในระบบ 'ดึง' ลูกค้าจะติดต่อกับเซิร์ฟเวอร์โดยไม่ขึ้นต่อกันดังนั้นระบบโดยรวมสามารถปรับขนาดได้มากกว่าระบบ 'ดัน'

ในอีกทางหนึ่ง Rackspace แสดงให้เห็นว่าพวกเขาสามารถจัดการกับระบบ 15Kด้วยรูปแบบการผลักดัน

infastructures.orgเขียน:

เราสาบานด้วยวิธีการดึงสำหรับการบำรุงรักษาโครงสร้างพื้นฐานโดยใช้เครื่องมือเช่น SUP, CVSup, เซิร์ฟเวอร์ rsync หรือ cfengine แทนที่จะผลักดันการเปลี่ยนแปลงไปยังไคลเอนต์แต่ละเครื่องไคลเอนต์แต่ละคนจะต้องรับผิดชอบในการสำรวจเซิร์ฟเวอร์ทองคำตอนบูตและหลังจากนั้นเป็นระยะเพื่อรักษาระดับการหมุนรอบของตัวเอง ก่อนที่จะนำมุมมองนี้มาใช้เราได้พัฒนาสคริปต์แบบพุชอิงที่มีพื้นฐานมาจาก ssh, rsh, rcp และ rdist ปัญหาที่เราพบกับคำสั่ง r-(หรือ ssh) คือ: เมื่อคุณรันสคริปต์ตามคำสั่ง r เพื่อผลักดันการเปลี่ยนแปลงไปยังเครื่องเป้าหมายของคุณอัตราต่อรองคือว่าถ้าคุณมีโฮสต์เป้าหมายมากกว่า 30 คนหนึ่งในนั้นจะ จะลงในเวลาใดก็ได้ การดูแลรักษารายชื่อของเครื่องจักรที่ได้รับหน้าที่กลายเป็นฝันร้าย ในระหว่างการเขียนโค้ดเพื่อแก้ไขสิ่งนี้คุณจะได้รับรหัส wrapper ที่ซับซ้อนเพื่อจัดการกับ: หมดเวลาจากโฮสต์ที่ตายแล้ว การบันทึกและลองโฮสต์ที่ตายแล้ว การฟอร์กและการรันงานแบบขนานเพื่อพยายามโฮสต์หลายโฮสต์ในเวลาที่เหมาะสม และในที่สุดก็ตรวจจับและป้องกันกรณีของการใช้ซ็อกเก็ต TCP ที่มีอยู่ทั้งหมดบนเครื่องต้นทางด้วยเซสชัน rsh ขาออกทั้งหมด จากนั้นคุณยังคงมีปัญหาในการรับสิ่งที่คุณเพิ่งทำลงไปในอิมเมจการติดตั้งสำหรับโฮสต์ใหม่ทั้งหมดที่จะติดตั้งในอนาคตเช่นเดียวกับการทำซ้ำสำหรับโฮสต์ที่ตายและต้องสร้างใหม่ในวันพรุ่งนี้ หลังจากปัญหาที่เราผ่านการใช้การจำลองแบบ r-command เราพบว่ามันไม่คุ้มค่า เราไม่ได้วางแผนเกี่ยวกับการจัดการโครงสร้างพื้นฐานด้วยคำสั่ง r อีกครั้งหรือกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม การฟอร์กและการรันงานแบบขนานเพื่อพยายามโฮสต์หลายโฮสต์ในเวลาที่เหมาะสม และในที่สุดก็ตรวจจับและป้องกันกรณีของการใช้ซ็อกเก็ต TCP ที่มีอยู่ทั้งหมดบนเครื่องต้นทางด้วยเซสชัน rsh ขาออกทั้งหมด จากนั้นคุณยังคงมีปัญหาในการรับสิ่งที่คุณเพิ่งทำลงไปในอิมเมจการติดตั้งสำหรับโฮสต์ใหม่ทั้งหมดที่จะติดตั้งในอนาคตเช่นเดียวกับการทำซ้ำสำหรับโฮสต์ที่ตายและต้องสร้างใหม่ในวันพรุ่งนี้ หลังจากปัญหาที่เราผ่านการใช้การจำลองแบบ r-command เราพบว่ามันไม่คุ้มค่า เราไม่ได้วางแผนเกี่ยวกับการจัดการโครงสร้างพื้นฐานด้วยคำสั่ง r อีกครั้งหรือกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม การฟอร์กและการรันงานแบบขนานเพื่อพยายามโฮสต์หลายโฮสต์ในเวลาที่เหมาะสม และในที่สุดการตรวจจับและป้องกันกรณีของการใช้ซ็อกเก็ต TCP ที่มีอยู่ทั้งหมดบนเครื่องต้นทางด้วยเซสชัน rsh ขาออกทั้งหมด จากนั้นคุณยังคงมีปัญหาในการรับสิ่งที่คุณเพิ่งทำลงไปในอิมเมจการติดตั้งสำหรับโฮสต์ใหม่ทั้งหมดที่จะติดตั้งในอนาคตเช่นเดียวกับการทำซ้ำสำหรับโฮสต์ที่ตายและต้องสร้างใหม่ในวันพรุ่งนี้ หลังจากปัญหาที่เราผ่านการใช้การจำลองแบบ r-command เราพบว่ามันไม่คุ้มค่า เราไม่ได้วางแผนเกี่ยวกับการจัดการโครงสร้างพื้นฐานด้วยคำสั่ง r อีกครั้งหรือกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม และในที่สุดการตรวจจับและป้องกันกรณีของการใช้ซ็อกเก็ต TCP ที่มีอยู่ทั้งหมดบนเครื่องต้นทางด้วยเซสชัน rsh ขาออกทั้งหมด จากนั้นคุณยังคงมีปัญหาในการรับสิ่งที่คุณเพิ่งทำลงไปในอิมเมจการติดตั้งสำหรับโฮสต์ใหม่ทั้งหมดที่จะติดตั้งในอนาคตเช่นเดียวกับการทำซ้ำสำหรับโฮสต์ที่ตายและต้องสร้างใหม่ในวันพรุ่งนี้ หลังจากปัญหาที่เราผ่านการใช้การจำลองแบบ r-command เราพบว่ามันไม่คุ้มค่า เราไม่ได้วางแผนเกี่ยวกับการจัดการโครงสร้างพื้นฐานด้วยคำสั่ง r อีกครั้งหรือกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม และในที่สุดการตรวจจับและป้องกันกรณีของการใช้ซ็อกเก็ต TCP ที่มีอยู่ทั้งหมดบนเครื่องต้นทางด้วยเซสชัน rsh ขาออกทั้งหมด จากนั้นคุณยังคงมีปัญหาในการรับสิ่งที่คุณเพิ่งทำลงไปในอิมเมจการติดตั้งสำหรับโฮสต์ใหม่ทั้งหมดที่จะติดตั้งในอนาคตเช่นเดียวกับการทำซ้ำสำหรับโฮสต์ที่ตายและต้องสร้างใหม่ในวันพรุ่งนี้ หลังจากปัญหาที่เราผ่านการใช้การจำลองแบบ r-command เราพบว่ามันไม่คุ้มค่า เราไม่ได้วางแผนเกี่ยวกับการจัดการโครงสร้างพื้นฐานด้วยคำสั่ง r อีกครั้งหรือกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม จากนั้นคุณยังคงมีปัญหาในการรับสิ่งที่คุณเพิ่งทำลงไปในอิมเมจการติดตั้งสำหรับโฮสต์ใหม่ทั้งหมดที่จะติดตั้งในอนาคตเช่นเดียวกับการทำซ้ำสำหรับโฮสต์ที่ตายและต้องสร้างใหม่ในวันพรุ่งนี้ หลังจากปัญหาที่เราผ่านการใช้การจำลองแบบ r-command เราพบว่ามันไม่คุ้มค่า เราไม่ได้วางแผนเกี่ยวกับการจัดการโครงสร้างพื้นฐานด้วยคำสั่ง r อีกครั้งหรือกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม จากนั้นคุณยังคงมีปัญหาในการรับสิ่งที่คุณเพิ่งทำลงไปในอิมเมจการติดตั้งสำหรับโฮสต์ใหม่ทั้งหมดที่จะติดตั้งในอนาคตเช่นเดียวกับการทำซ้ำสำหรับโฮสต์ที่ตายและต้องสร้างใหม่ในวันพรุ่งนี้ หลังจากปัญหาที่เราผ่านการใช้การจำลองแบบ r-command เราพบว่ามันไม่คุ้มค่า เราไม่ได้วางแผนเกี่ยวกับการจัดการโครงสร้างพื้นฐานด้วยคำสั่ง r อีกครั้งหรือด้วยกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม หรือกับกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม หรือกับกลไกการผลักดันอื่น ๆ สำหรับเรื่องนั้น พวกเขาไม่ได้ปรับขนาดเช่นเดียวกับวิธีการดึงตาม

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

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

เห็นได้ชัดว่าสามารถใช้งานได้ แต่ต้องใช้เวลามากในการซิงค์

การใช้สิ่งต่าง ๆ เช่น Mcollective คุณสามารถแปลง Puppet และ CM อื่น ๆ ให้เป็นระบบที่ใช้การพุช โดยทั่วไปแล้วมันเป็นเรื่องเล็กน้อยที่จะแปลงระบบดึงให้เป็นระบบที่ใช้แรงผลักดัน แต่ไม่ง่ายเสมอไปที่จะไปทางอื่น

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

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

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

ประสบการณ์เมื่อเร็ว ๆ นี้ของฉันเป็นที่นิยมอย่างมากในการผลักดันให้เกิดการเปลี่ยนแปลงอย่างมากมายจากหลายสิบถึงหลายร้อยเซิร์ฟเวอร์ซึ่งสามารถขยายหรือลดขนาดถูกยกเลิกและรีเฟรช ในสถานการณ์ของฉันคำสั่ง Ad Hoc แบบง่าย Ansible 1.7 คือทั้งหมดที่ฉันต้องการเพื่อทำการแก้ไข อย่างไรก็ตามในมุมมองของประสิทธิภาพของการตั้งค่า AnsibleController (บน t2.micro) ต่อ Vpc สำหรับวัตถุประสงค์ในอนาคตฉันตั้งใจจะขยายเทคนิคสำหรับความต้องการที่ซับซ้อนมากขึ้น

ดังนั้นให้ฉันกลับไปที่คำถามที่ถามในหัวข้อนี้: ข้อดีและข้อเสียของการผลักดันในอสังหาริมทรัพย์ที่เปลี่ยนแปลงตลอดเวลา

สมมติฐานของเซิร์ฟเวอร์คุณสมบัติที่ฉันกำหนดเป้าหมายคือ:

• ไม่มีข้อสันนิษฐานว่าที่อยู่ IP หรือชื่อโฮสต์ในพื้นที่ที่ Amazon สร้างขึ้นจะยั่งยืน - ทั้งคู่สามารถไปมาได้
• อินสแตนซ์ทั้งหมดถูกสร้างขึ้นจากอิมเมจของเครื่องซึ่งมีความสามารถในการเข้าถึง ssh จากผู้ใช้ที่มีสิทธิพิเศษรายเดียว
• เพื่อแบ่งแยกเซิร์ฟเวอร์และแบ่งพาร์ติชันออกเป็นกลุ่มตามหน้าที่หรือตามขั้นตอนของการพัฒนา (เช่นทดสอบหรือแยง) สิ่งนี้จะกระทำผ่านการเปิดตัวแท็ก Amazon เฉพาะของชื่อธรรมดาที่ตกลงกัน
• ว่าฉันจะแก้ไขจัดการเซิร์ฟเวอร์ Linux และ Windows แยกกันด้วยคำสั่ง ad hoc ที่แตกต่างกันดังนั้นเพียงแค่ให้การเข้าสู่ระบบเฉพาะ Linux ล้มเหลวเมื่อติดต่อเซิร์ฟเวอร์ Windows เป็นที่ยอมรับอย่างสมบูรณ์

ด้วยเงื่อนไขเหล่านี้ในใจการสร้างอิมเมจเครื่องของ AnsibleController เพื่อปล่อยลงใน Vpcs จำนวนมากและกำหนดค่า (ด้วยข้อมูลประจำตัว) ในแหล่งกำเนิดภายในบัญชีเซิร์ฟเวอร์ที่มีอยู่นั้นง่ายมาก อัตโนมัติภายในแต่ละอินสแตนซ์ที่สร้างจากภาพคือ

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

รายการที่สองสามารถทำให้ค่อนข้างซับซ้อนหากจำเป็น (ผ่านโครงสร้างข้อมูลของสินค้าคงคลัง Ansible) แต่ถ้าไม่ต้องการความซับซ้อนนี่เป็นตัวอย่างที่ตรงไปตรงมามากของสคริปต์เพื่อคำนวณอินสแตนซ์ Amazon EC2 ทั้งหมดในแต่ละช่วงเวลา cron และนำผลลัพธ์ไปสู่ไฟล์คลังที่เหมาะสม (เช่น / etc / ansible / hosts) ...

#!/bin/bash
# Assumes aws-cli/1.3.4 Python/2.6.9 Linux/3.4.73-64.112.amzn1.x86_64 or greater
# http://aws.amazon.com/releasenotes/8906204440930658
# To check yum list aws-cli
# Assumes that server is equipped with AWS keys and is able to access some or all
# instances in the account within it is running.
# Provide a list of host IPs each on a separate line
# If an argument is passed then treat it as the filename, whether local or absolute 
# path, to which the list is written

function list-of-ips {
    /usr/bin/aws ec2 describe-instances --filters '[ {"Name": "instance-state-code", "Values": [ "16" ] } ]' | grep -w PrivateIpAddress | awk  '{x=$2; gsub("\"","", x); gsub(",","", x); if(x && FNR!=1){print x;}}' | uniq
 }

if [ -n "$1" ]; then
   list-of-ips > "$1"
else
   list-of-ips
fi

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

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