Docker แตกต่างจากเครื่องเสมือนจริงอย่างไร

ฉันทำการอ่านเอกสาร Docker อีกครั้งเพื่อพยายามเข้าใจความแตกต่างระหว่าง Docker และ VM แบบเต็ม มันจะจัดการให้ระบบไฟล์เต็มรูปแบบสภาพแวดล้อมเครือข่ายที่แยกได้ ฯลฯ โดยไม่หนักหนาได้อย่างไร

ทำไมการปรับใช้ซอฟต์แวร์กับอิมเมจ Docker (หากเป็นคำที่ถูกต้อง) ง่ายกว่าการปรับใช้กับสภาพแวดล้อมการผลิตที่สอดคล้องกัน

Docker เดิมใช้LinuX Containers (LXC) แต่ต่อมาเปลี่ยนเป็นrunC (เดิมชื่อlibcontainer ) ซึ่งทำงานในระบบปฏิบัติการเดียวกับโฮสต์ สิ่งนี้ทำให้สามารถแชร์ทรัพยากรระบบปฏิบัติการโฮสต์ได้จำนวนมาก นอกจากนี้ยังใช้ระบบไฟล์แบบเลเยอร์ ( AuFS ) และจัดการเครือข่าย

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

สมมติว่าคุณมีรูปคอนเทนเนอร์ 1 GB หากคุณต้องการใช้ VM แบบเต็มคุณจะต้องมีจำนวน 1 GB x VMs ที่คุณต้องการ ด้วย Docker และ AuFS คุณสามารถแบ่งปันจำนวน 1 GB ระหว่างคอนเทนเนอร์ทั้งหมดและถ้าคุณมี 1,000 คอนเทนเนอร์คุณยังอาจมีพื้นที่ว่างเพียง 1 GB สำหรับ OS OS ตู้คอนเทนเนอร์ (สมมติว่าพวกเขากำลังเรียกใช้อิมเมจระบบปฏิบัติการเดียวกันทั้งหมด) .

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

ระบบเสมือนจริงเต็มรูปแบบมักใช้เวลาหลายนาทีในการเริ่มต้นในขณะที่คอนเทนเนอร์ Docker / LXC / runC ใช้เวลาไม่กี่วินาทีและมักจะน้อยกว่าหนึ่งวินาที

มีข้อดีข้อเสียสำหรับระบบเสมือนจริงแต่ละประเภท หากคุณต้องการการแยกอย่างสมบูรณ์กับทรัพยากรที่มีการรับประกัน VM แบบเต็มเป็นวิธีที่จะไป หากคุณต้องการแยกกระบวนการออกจากกันและต้องการเรียกใช้กระบวนการจำนวนมากบนโฮสต์ที่มีขนาดพอสมควรดูเหมือนว่า Docker / LXC / runC จะเป็นวิธีที่จะไป

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

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

การปรับใช้สภาพแวดล้อมการผลิตที่สอดคล้องนั้นง่ายกว่าการพูด แม้ว่าคุณจะใช้เครื่องมือเช่นChefและPuppetแต่ก็มีอัปเดตระบบปฏิบัติการและสิ่งอื่น ๆ ที่เปลี่ยนแปลงระหว่างโฮสต์และสภาพแวดล้อมอยู่เสมอ

นักเทียบท่าช่วยให้คุณสามารถจับภาพ OS เป็นภาพที่แชร์และทำให้ง่ายต่อการปรับใช้กับโฮสต์ Docker อื่น ๆ ในพื้นที่ dev, qa, prod, ฯลฯ : ภาพเดียวกันทั้งหมด แน่นอนว่าคุณสามารถทำได้ด้วยเครื่องมืออื่น ๆ แต่ไม่สามารถทำได้อย่างง่ายดายหรือรวดเร็ว

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

จากความคิดเห็น ...

! ที่น่าสนใจ ฉันคิดว่าฉันยังคงสับสนกับแนวคิด "snapshot [ting] ระบบปฏิบัติการ" เราจะทำอย่างนั้นได้อย่างไรโดยไม่สร้างภาพของระบบปฏิบัติการ

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

คำตอบที่ดี เพียงเพื่อให้ได้รูปภาพที่เป็นตัวแทนของ container vs VM ให้ดูที่ด้านล่าง

แหล่ง

อาจเป็นประโยชน์ในการทำความเข้าใจว่า virtualization และคอนเทนเนอร์ทำงานในระดับต่ำ ที่จะล้างสิ่งต่าง ๆ มากมาย

หมายเหตุ: ฉันกำลังทำให้เข้าใจง่ายขึ้นเล็กน้อยในการอธิบายด้านล่าง ดูการอ้างอิงสำหรับข้อมูลเพิ่มเติม

virtualization ทำงานในระดับต่ำได้อย่างไร

ในกรณีนี้ผู้จัดการ VM จะเข้ามาแทนที่ซีพียูริง 0 (หรือ "รูทโหมด" ในซีพียูรุ่นใหม่กว่า) และสกัดกั้นการโทรที่ได้รับสิทธิพิเศษทั้งหมดที่ทำโดยระบบปฏิบัติการของแขกเพื่อสร้างภาพลวงตาที่ guest OS มีฮาร์ดแวร์ของตัวเอง เรื่องจริงเรื่องสนุก: ก่อนปี 1998 มันเป็นความคิดที่เป็นไปไม่ได้ที่จะบรรลุสิ่งนี้ในสถาปัตยกรรม x86 เพราะไม่มีทางที่จะทำการสกัดกั้นแบบนี้ คนที่ VMWare เป็นคนแรกที่มีความคิดที่จะเขียนไบต์ปฏิบัติการในหน่วยความจำสำหรับการโทรที่มีสิทธิพิเศษของ guest OS เพื่อให้บรรลุสิ่งนี้

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

ภาชนะบรรจุทำงานในระดับต่ำได้อย่างไร

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

ข้อ จำกัด ของคอนเทนเนอร์ vs VM ควรชัดเจนแล้วในตอนนี้: คุณไม่สามารถเรียกใช้ระบบปฏิบัติการที่แตกต่างอย่างสิ้นเชิงในตู้คอนเทนเนอร์เช่นเดียวกับใน VM อย่างไรก็ตามคุณสามารถเรียกใช้ distros ที่แตกต่างกันของ Linux เพราะพวกเขาแบ่งปันเคอร์เนลเดียวกัน ระดับการแยกไม่แข็งแรงเท่าใน VM ในความเป็นจริงมีวิธีสำหรับคอนเทนเนอร์ "แขก" เพื่อใช้เป็นเจ้าภาพในการใช้งานในช่วงต้น นอกจากนี้คุณจะเห็นได้ว่าเมื่อคุณโหลดคอนเทนเนอร์ใหม่สำเนาระบบปฏิบัติการใหม่ทั้งหมดจะไม่เริ่มต้นเหมือนใน VM คอนเทนเนอร์ทั้งหมดแชร์เคอร์เนลเดียวกัน. นี่คือเหตุผลที่ภาชนะบรรจุมีน้ำหนักเบา ไม่เหมือนกับ VM คุณไม่ต้องจัดสรรหน่วยความจำจำนวนมากให้กับคอนเทนเนอร์ล่วงหน้าเนื่องจากเราไม่ได้ใช้งานระบบปฏิบัติการใหม่ สิ่งนี้ช่วยให้สามารถเรียกใช้คอนเทนเนอร์หลายพันรายการบนระบบปฏิบัติการเดียวในขณะที่ใช้ Sandbox ซึ่งอาจเป็นไปไม่ได้ที่จะทำถ้าเราใช้ระบบปฏิบัติการแยกต่างหากใน VM ของตัวเอง

ฉันชอบคำตอบของ Ken Cochrane

แต่ฉันต้องการเพิ่มมุมมองเพิ่มเติมไม่ครอบคลุมในรายละเอียดที่นี่ ในความคิดของฉันนักเทียบท่าแตกต่างกันในกระบวนการทั้งหมด ในทางตรงกันข้ามกับ VM นั้น Docker ไม่ได้เป็นเพียงเกี่ยวกับการแบ่งปันทรัพยากรที่ดีที่สุดของฮาร์ดแวร์นอกจากนี้ยังมี "ระบบ" สำหรับแอปพลิเคชันบรรจุภัณฑ์ (ดีกว่า แต่ไม่ต้องเป็นชุดของไมโครซอฟท์)

สำหรับฉันมันเหมาะกับช่องว่างระหว่างเครื่องมือเชิงผู้พัฒนาเช่น rpm, แพ็คเกจDebian , Maven , npm + Git ที่ด้านหนึ่งและเครื่องมือ ops เช่นPuppet , VMware, Xen คุณชื่อมัน ...

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

คำถามของคุณสมมติว่ามีสภาพแวดล้อมการผลิตที่สอดคล้องกัน แต่จะทำให้มันสอดคล้องกันได้อย่างไร? พิจารณาจำนวน (> 10) ของเซิร์ฟเวอร์และแอปพลิเคชัน

ในการทำให้ข้อมูลตรงกันคุณจะเริ่มใช้บางอย่างเช่น Puppet, Chefหรือสคริปต์การจัดสรรของคุณเอง, กฎที่ไม่ได้เผยแพร่และ / หรือเอกสารจำนวนมาก ... ในทางทฤษฎีเซิร์ฟเวอร์สามารถทำงานได้อย่างไม่มีกำหนดและคงไว้ซึ่งความสมบูรณ์และทันสมัย การปฏิบัติล้มเหลวในการจัดการการกำหนดค่าเซิร์ฟเวอร์อย่างสมบูรณ์ดังนั้นจึงมีขอบเขตที่สำคัญสำหรับการเลื่อนการกำหนดค่าและการเปลี่ยนแปลงที่ไม่คาดคิดกับเซิร์ฟเวอร์ที่ใช้งาน

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

ด้วยระบบนิเวศของนักเทียบท่าคุณจะไม่ต้องย้ายไปรอบ ๆ กิกะไบต์ด้วย "การเปลี่ยนแปลงเล็กน้อย" (ขอบคุณ aufs และ Registry) และคุณไม่ต้องกังวลกับการสูญเสียประสิทธิภาพโดยการใช้งานบรรจุภัณฑ์ลงในคอนเทนเนอร์ Docker ที่รันไทม์ คุณไม่จำเป็นต้องกังวลเกี่ยวกับรูปภาพในเวอร์ชันนั้น

และในที่สุดคุณก็จะสามารถสร้างสภาพแวดล้อมการผลิตที่ซับซ้อนได้บนแล็ปท็อป Linux ของคุณ (อย่าโทรหาฉันหากไม่ได้ผลในกรณีของคุณ;)

และแน่นอนคุณสามารถเริ่ม Docker container ใน VMs (เป็นความคิดที่ดี) ลดการจัดสรรเซิร์ฟเวอร์ของคุณในระดับ VM ทั้งหมดข้างต้นสามารถจัดการได้โดยนักเทียบท่า

PS ในขณะเดียวกัน Docker ใช้ "libcontainer" ของตัวเองแทน LXC แต่ LXC ยังใช้งานได้อยู่

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

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

virtualization

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

hypervisor

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

การพัฒนาอย่างรวดเร็วของเทคโนโลยีการจำลองเสมือนส่วนใหญ่ในระบบคลาวด์ได้ผลักดันให้มีการใช้งานการจำลองเสมือนเพิ่มเติมโดยอนุญาตให้เซิร์ฟเวอร์เสมือนหลายตัวถูกสร้างขึ้นบนเซิร์ฟเวอร์ทางกายภาพเดียวด้วยความช่วยเหลือของไฮเปอร์ไวเซอร์เช่น Xen, VMware Player, KVM เป็นต้น การรวมการสนับสนุนฮาร์ดแวร์ในตัวประมวลผลสินค้าเช่น Intel VT และ AMD-V

ประเภทของการจำลองเสมือน

วิธีการจำลองเสมือนสามารถจัดประเภทตามวิธีที่เลียนแบบฮาร์ดแวร์กับระบบปฏิบัติการของแขกและจำลองสภาพแวดล้อมการปฏิบัติการของแขก ในขั้นต้นมี virtualization สามประเภท:

• การแข่งขัน
• paravirtualization
• การจำลองเสมือนตามคอนเทนเนอร์

การแข่งขัน

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

ตัวอย่างในหมวดหมู่นี้ ได้แก่ VMware Player, VirtualBox, QEMU, Bochs, Parallels เป็นต้น

paravirtualization

Paravirtualization หรือที่รู้จักในชื่อ Type 1 hypervisor รันบนฮาร์ดแวร์โดยตรงหรือ "bare-metal" และให้บริการการจำลองเสมือนโดยตรงกับเครื่องเสมือนที่รันอยู่ ช่วยให้ระบบปฏิบัติการฮาร์ดแวร์เสมือนจริงและฮาร์ดแวร์จริงทำงานร่วมกันเพื่อให้ได้ประสิทธิภาพสูงสุด โดยทั่วไปแล้วไฮเปอร์ไวเซอร์เหล่านี้มีรอยเท้าที่ค่อนข้างเล็กและไม่ต้องการทรัพยากรที่กว้างขวาง

ตัวอย่างในหมวดหมู่นี้ ได้แก่ Xen, KVM เป็นต้น

การจำลองเสมือนตามคอนเทนเนอร์

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

แนวคิดของคอนเทนเนอร์ถูกสร้างขึ้นโดยคุณลักษณะเนมสเปซที่เพิ่มใน Linux kernel เวอร์ชัน 2.6.24 คอนเทนเนอร์เพิ่ม ID ไปยังทุกกระบวนการและเพิ่มการตรวจสอบการควบคุมการเข้าถึงใหม่ให้กับการเรียกระบบทุกครั้ง มันเข้าถึงได้โดยโคลน ()เรียกระบบที่ช่วยให้การสร้างอินสแตนซ์ที่แยกจากกันของ namespaces ก่อนหน้านี้ทั่วโลก

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

ระบบย่อย Linux Control Groups (cgroups) ซึ่งเป็นองค์ประกอบหลักถัดไปเพื่อเปิดใช้งานการจำลองเสมือนแบบคอนเทนเนอร์ใช้สำหรับจัดกลุ่มกระบวนการและจัดการการใช้ทรัพยากรรวมของพวกเขา มักใช้เพื่อ จำกัด หน่วยความจำและปริมาณการใช้ CPU ของคอนเทนเนอร์ เนื่องจากระบบ Linux ที่บรรจุแล้วมีเพียงหนึ่งเคอร์เนลและเคอร์เนลมีการมองเห็นอย่างเต็มรูปแบบในคอนเทนเนอร์จึงมีการจัดสรรทรัพยากรและการกำหนดตารางเวลาเพียงระดับเดียวเท่านั้น

เครื่องมือการจัดการหลายอย่างพร้อมใช้งานสำหรับคอนเทนเนอร์ Linux รวมถึง LXC, LXD, systemd-nspawn, lmctfy, Warden, Linux-VServer, OpenVZ, Docker เป็นต้น

ตู้เทียบกับเครื่องเสมือน

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

เนื่องจากการจำลองเสมือนแบบคอนเทนเนอร์ใช้เพิ่มค่าใช้จ่ายเพียงเล็กน้อยหรือไม่มีเลยให้กับเครื่องโฮสต์การจำลองเสมือนตามคอนเทนเนอร์จึงมีประสิทธิภาพใกล้เคียง

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

คอนเทนเนอร์ทั้งหมดบนเครื่องโฮสต์ใช้ตัวกำหนดตารางเวลาของเครื่องโฮสต์ที่ต้องการประหยัดทรัพยากรเพิ่มเติม

สถานะคอนเทนเนอร์ (อิมเมจ Docker หรือ LXC) มีขนาดเล็กเมื่อเทียบกับอิมเมจเครื่องเสมือนดังนั้นอิมเมจคอนเทนเนอร์จึงง่ายต่อการกระจาย

การจัดการทรัพยากรในคอนเทนเนอร์สามารถทำได้ผ่าน cgroups Cgroups ไม่อนุญาตให้คอนเทนเนอร์ใช้ทรัพยากรมากกว่าที่จัดสรรให้ อย่างไรก็ตาม ณ ตอนนี้ทรัพยากรทั้งหมดของเครื่องโฮสต์จะมองเห็นได้ในเครื่องเสมือน แต่ไม่สามารถใช้งานได้ สิ่งนี้สามารถรับรู้ได้โดยการรันtopหรือhtopบนคอนเทนเนอร์และเครื่องโฮสต์ในเวลาเดียวกัน ผลลัพธ์ในทุกสภาพแวดล้อมจะมีลักษณะใกล้เคียงกัน

ปรับปรุง:

นักเทียบท่าเรียกใช้คอนเทนเนอร์ในระบบที่ไม่ใช่ Linux อย่างไร

หากคอนเทนเนอร์เป็นไปได้เนื่องจากคุณสมบัติที่มีอยู่ในเคอร์เนล Linux คำถามที่ชัดเจนคือระบบที่ไม่ใช่ Linux ใช้คอนเทนเนอร์ได้อย่างไร ทั้ง Docker สำหรับ Mac และ Windows ใช้ Linux VM เพื่อเรียกใช้คอนเทนเนอร์ Docker Toolbox ใช้เพื่อเรียกใช้คอนเทนเนอร์ใน Virtual Box VMs แต่นักเทียบท่ารุ่นล่าสุดใช้ Hyper-V ใน Windows และ Hypervisor.framework ใน Mac

ตอนนี้ฉันจะอธิบายว่า Docker for Mac ใช้งานคอนเทนเนอร์อย่างไรในรายละเอียด

Docker สำหรับ Mac ใช้https://github.com/moby/hyperkitเพื่อจำลองความสามารถด้านไฮเปอร์ไวเซอร์และ Hyperkit ใช้ hypervisor.framework ในแกนกลาง Hypervisor.framework เป็นโซลูชันไฮเปอร์ไวเซอร์ดั้งเดิมของ Mac ไฮเปอร์คิตยังใช้ VPNKit และ DataKit ในการกำหนดชื่อเครือข่ายและระบบไฟล์ตามลำดับ

Linux VM ที่ Docker รันใน Mac เป็นแบบอ่านอย่างเดียว อย่างไรก็ตามคุณสามารถทุบตีมันโดยการเรียกใช้:

screen ~/Library/Containers/com.docker.docker/Data/vms/0/tty.

ตอนนี้เราสามารถตรวจสอบเวอร์ชันเคอร์เนลของ VM นี้:

# uname -a Linux linuxkit-025000000001 4.9.93-linuxkit-aufs #1 SMP Wed Jun 6 16:86_64 Linux.

คอนเทนเนอร์ทั้งหมดทำงานภายใน VM นี้

มีข้อ จำกัด บางประการสำหรับ hypervisor.framework เนื่องจาก Docker นั้นไม่ได้เปิดเผยdocker0อินเตอร์เฟสเครือข่ายใน Mac ดังนั้นคุณไม่สามารถเข้าถึงคอนเทนเนอร์จากโฮสต์ ณ ตอนนี้docker0ใช้ได้เฉพาะภายใน VM

Hyper-v เป็นไฮเปอร์ไวเซอร์เนทีฟใน Windows พวกเขายังพยายามยกระดับความสามารถของ Windows 10 ในการใช้งานระบบ Linux ด้วย

จากการโพสต์นี้เราจะวาดเส้นบาง ๆ ของความแตกต่างระหว่าง VMs และ LXC ก่อนอื่นมานิยามกันก่อน

VM :

เครื่องเสมือนจำลองสภาพแวดล้อมการคำนวณทางกายภาพ แต่การร้องขอ CPU, หน่วยความจำ, ฮาร์ดดิสก์, เครือข่ายและทรัพยากรฮาร์ดแวร์อื่น ๆ ได้รับการจัดการโดยเลเยอร์เสมือนจริงซึ่งแปลคำขอเหล่านี้ไปยังฮาร์ดแวร์ทางกายภาพพื้นฐาน

ในบริบทนี้ VM เรียกว่าเป็นแขกในขณะที่สภาพแวดล้อมที่ทำงานบนเรียกว่าโฮสต์

LXC s:

Linux Containers (LXC) เป็นความสามารถระดับระบบปฏิบัติการที่ทำให้สามารถเรียกใช้คอนเทนเนอร์ Linux ที่แยกได้หลายตัวบนโฮสต์การควบคุมเดียว (โฮสต์ LXC) Linux Containers ทำหน้าที่เป็นทางเลือกที่มีน้ำหนักเบาสำหรับ VMs เนื่องจากไม่ต้องการ hypervisors viz Virtualbox, KVM, Xen ฯลฯ

ทีนี้ถ้าคุณไม่ได้ดื่มโดย Alan (Zach Galifianakis- จาก Hangover series) และอยู่ที่ Vegas ในปีที่แล้วคุณจะรู้ตัวเกี่ยวกับความสนใจของเทคโนโลยีตู้คอนเทนเนอร์ Linux และถ้าฉันจะเป็นตู้คอนเทนเนอร์หนึ่งตู้ โครงการที่สร้างความฮือฮาทั่วโลกในช่วงไม่กี่เดือนที่ผ่านมาคือ - นักเทียบท่าที่นำไปสู่ความคิดเห็นที่สะท้อนว่าสภาพแวดล้อมการประมวลผลแบบคลาวด์ควรละทิ้งเครื่องเสมือน (VMs) และแทนที่ด้วยคอนเทนเนอร์เนื่องจากค่าใช้จ่ายต่ำ

แต่คำถามใหญ่ก็คือมันเป็นไปได้ไหมจะเป็นไปได้ไหม

LXCs ถูกกำหนดขอบเขตให้กับอินสแตนซ์ของ Linux มันอาจมีรสชาติที่แตกต่างกันของ Linux (เช่นคอนเทนเนอร์ Ubuntu บนโฮสต์ CentOS แต่ยังคงเป็น Linux) ในทำนองเดียวกันคอนเทนเนอร์ที่ใช้ Windows จะถูกกำหนดขอบเขตไปยังอินสแตนซ์ของ Windows ทันทีหากเราดู VM ที่มีขอบเขตค่อนข้างกว้างและใช้ ไฮเปอร์ไวเซอร์ที่คุณไม่ได้ จำกัด อยู่ที่ระบบปฏิบัติการ Linux หรือ Windows

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

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

การละทิ้ง VMs ยังไม่สามารถใช้งานได้ในขณะนี้ ดังนั้นทั้ง VM และ LXC จึงมีการดำรงอยู่และความสำคัญของตนเอง

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

นักเทียบท่าเป็นเพียงวิธีแฟนซีในการเรียกใช้กระบวนการไม่ใช่เครื่องเสมือน

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

คอนเทนเนอร์ Docker เป็นเพียงโปรเซส (และลูก ๆ ) ที่ถูกแบ่งออกโดยใช้กลุ่มcgภายในเคอร์เนลของระบบโฮสต์จากส่วนที่เหลือของกระบวนการ คุณสามารถเห็นกระบวนการคอนเทนเนอร์ Docker ของคุณได้จริงโดยเรียกใช้ps auxบนโฮสต์ ตัวอย่างเช่นการเริ่มต้นapache2"ในคอนเทนเนอร์" เป็นเพียงการเริ่มต้นapache2เป็นกระบวนการพิเศษในโฮสต์ มันเพิ่งถูกแยกจากกระบวนการอื่น ๆ บนเครื่อง เป็นสิ่งสำคัญที่จะต้องทราบว่าบรรจุภัณฑ์ของคุณไม่มีอยู่นอกช่วงอายุการใช้งานกระบวนการของคุณ เมื่อกระบวนการของคุณตายคอนเทนเนอร์ของคุณจะตาย นั่นเป็นเพราะนักเทียบท่าแทนที่pid 1ภายในคอนเทนเนอร์ของคุณด้วยแอปพลิเคชันของคุณ ( pid 1โดยปกติคือระบบ init) ประเด็นสุดท้ายเกี่ยวกับเรื่องpid 1นี้สำคัญมาก

เท่าที่ระบบแฟ้มที่ใช้โดยแต่ละกระบวนการภาชนะเหล่านั้นใช้หางUnionFS -backed docker pull ubuntuภาพซึ่งเป็นสิ่งที่คุณกำลังดาวน์โหลดเมื่อคุณทำ "รูปภาพ" แต่ละรายการเป็นเพียงชุดของเลเยอร์และข้อมูลเมตาที่เกี่ยวข้อง แนวคิดของการฝังรากลึกเป็นสิ่งสำคัญมากที่นี่ แต่ละชั้นเป็นเพียงการเปลี่ยนแปลงจากชั้นใต้ ตัวอย่างเช่นเมื่อคุณลบไฟล์ใน Dockerfile ของคุณขณะสร้างคอนเทนเนอร์ Docker คุณเพียงแค่สร้างเลเยอร์ที่ด้านบนสุดของเลเยอร์สุดท้ายซึ่งระบุว่า "ไฟล์นี้ถูกลบแล้ว" นี่คือสาเหตุที่คุณสามารถลบไฟล์ขนาดใหญ่ออกจากระบบไฟล์ของคุณได้ แต่ภาพยังคงใช้พื้นที่ดิสก์ในปริมาณเท่าเดิม ไฟล์ยังคงมีอยู่ในเลเยอร์ที่อยู่ใต้ไฟล์ปัจจุบัน เลเยอร์ของตัวเองเป็นเพียงไฟล์ tarballs คุณสามารถทดสอบสิ่งนี้ด้วยdocker save --output /tmp/ubuntu.tar ubuntucd /tmp && tar xvf ubuntu.tarแล้วก็ จากนั้นคุณสามารถดูรอบ ๆ ไดเรกทอรีทั้งหมดที่มีลักษณะเหมือนแฮชที่ยาวจริง ๆ แล้วเป็นเลเยอร์เดี่ยว ๆ แต่ละคนมีไฟล์ (layer.tar ) และข้อมูลเมตา (json) พร้อมข้อมูลเกี่ยวกับเลเยอร์เฉพาะนั้น เลเยอร์เหล่านั้นอธิบายการเปลี่ยนแปลงของระบบไฟล์ที่ถูกบันทึกเป็นเลเยอร์ "ด้านบนของ" สถานะดั้งเดิม เมื่ออ่านข้อมูล "ปัจจุบัน" ระบบไฟล์จะอ่านข้อมูลราวกับว่ามันเป็นเพียงการเปลี่ยนแปลงที่เลเยอร์บนสุดเท่านั้น นั่นเป็นสาเหตุที่ไฟล์ดูเหมือนว่าจะถูกลบถึงแม้ว่ามันจะยังคงอยู่ในเลเยอร์ "ก่อนหน้า" เพราะระบบไฟล์ดูเฉพาะเลเยอร์ที่อยู่ด้านบนสุดเท่านั้น สิ่งนี้ทำให้คอนเทนเนอร์ที่แตกต่างกันอย่างสมบูรณ์สามารถแชร์เลเยอร์ระบบไฟล์ของพวกเขาแม้ว่าการเปลี่ยนแปลงที่สำคัญบางอย่างอาจเกิดขึ้นกับระบบไฟล์ในเลเยอร์ที่สูงที่สุดในแต่ละคอนเทนเนอร์ สิ่งนี้สามารถประหยัดพื้นที่ดิสก์ได้มากเมื่อคอนเทนเนอร์ของคุณแชร์เลเยอร์อิมเมจพื้นฐาน อย่างไรก็ตาม

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

นักเทียบท่ากำลังเคลื่อนที่เร็วมาก เอกสารมันเป็นเอกสารที่ดีที่สุดที่ฉันเคยเห็น โดยทั่วไปแล้วจะเป็นลายลักษณ์อักษรกระชับและถูกต้อง ฉันขอแนะนำให้คุณตรวจสอบเอกสารที่มีอยู่สำหรับข้อมูลเพิ่มเติมและเชื่อถือเอกสารมากกว่าสิ่งอื่นใดที่คุณอ่านออนไลน์รวมถึง Stack Overflow หากคุณมีคำถามที่เฉพาะเจาะจงฉันขอแนะนำให้เข้าร่วม#dockerใน Freenode IRC และถามที่นั่น (คุณสามารถใช้เว็บแชทของ Freenode ได้!)

นักเทียบท่าห่อหุ้มแอปพลิเคชันที่มีการอ้างอิงทั้งหมด

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

พวกเขาทั้งสองแตกต่างกันมาก Docker มีน้ำหนักเบาและใช้ LXC / libcontainer (ซึ่งขึ้นอยู่กับการกำหนดตำแหน่งเคอร์เนลและกลุ่ม cg) และไม่มีการจำลองเครื่อง / ฮาร์ดแวร์เช่น hypervisor, KVM เซนซึ่งหนัก

นักเทียบท่าและ LXC มีความหมายมากขึ้นสำหรับการทำแซนด์บ็อกซ์การทำคอนเทนเนอร์และการแยกทรัพยากร ใช้โฮสต์ API (โคลนเคอร์เนล Linux) ของโฮสต์ OS ซึ่งให้การกำหนดเนมสเปซสำหรับ IPC, NS (เมาท์), เครือข่าย, PID, UTS ฯลฯ

หน่วยความจำ I / O, CPU มีอะไรบ้าง? ที่ถูกควบคุมโดยใช้ cgroups ซึ่งคุณสามารถสร้างกลุ่มที่มีข้อกำหนด (ข้อ จำกัด ของ CPU, หน่วยความจำ, ฯลฯ ) และวางกระบวนการของคุณ นอกจาก LXC แล้ว Docker ยังมีแบ็กเอนด์หน่วยเก็บข้อมูล ( http://www.projectatomic.io/docs/filesystems/ ) เช่นระบบไฟล์ยูเนี่ยนเมาท์ที่คุณสามารถเพิ่มเลเยอร์และแชร์เลเยอร์ระหว่างเมาท์เนมสเปซที่แตกต่างกัน

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

ด้วย LXC ปกติคุณต้องมาพร้อมกับ rootfs บางส่วนหรือแบ่งปัน rootfs และเมื่อใช้ร่วมกันและการเปลี่ยนแปลงจะมีผลกับคอนเทนเนอร์อื่น ๆ เนื่องจากคุณสมบัติที่เพิ่มเข้ามาจำนวนมากเหล่านี้ Docker จึงเป็นที่นิยมมากกว่า LXC LXC ได้รับความนิยมในสภาพแวดล้อมแบบฝังตัวสำหรับการใช้งานการรักษาความปลอดภัยรอบ ๆ กระบวนการที่เปิดเผยต่อหน่วยงานภายนอกเช่นเครือข่ายและ UI นักเทียบท่าได้รับความนิยมในสภาพแวดล้อมคลาวด์ที่มีหลายผู้เช่าซึ่งคาดว่าจะมีสภาพแวดล้อมการผลิตที่สอดคล้องกัน

VM ปกติ (ตัวอย่างเช่น VirtualBox และ VMware) ใช้ไฮเปอร์ไวเซอร์และเทคโนโลยีที่เกี่ยวข้องมีเฟิร์มแวร์เฉพาะที่กลายเป็นเลเยอร์แรกสำหรับ OS แรก (โฮสต์ระบบปฏิบัติการหรือเกสต์ OS 0) หรือซอฟต์แวร์ที่ทำงานบนโฮสต์ระบบปฏิบัติการเพื่อ จัดหาการจำลองฮาร์ดแวร์เช่น CPU, USB / อุปกรณ์เสริม, หน่วยความจำ, เครือข่าย, ฯลฯ ให้กับระบบปฏิบัติการเกสต์ VMs นั้นยังคงเป็นที่นิยมในสภาพแวดล้อมที่มีผู้เช่าหลายรายที่มีความปลอดภัยสูง

นักเทียบท่า / LXC สามารถทำงานบนฮาร์ดแวร์ราคาถูก ๆ ได้ (หน่วยความจำน้อยกว่า 1 GB ก็โอเคตราบใดที่คุณมีเคอร์เนลที่ใหม่กว่า) กับ VM ปกติต้องการหน่วยความจำอย่างน้อย 2 GB ฯลฯ เพื่อทำสิ่งใดที่มีความหมายกับมัน . แต่การสนับสนุน Docker บนโฮสต์ระบบปฏิบัติการไม่สามารถใช้งานได้ในระบบปฏิบัติการเช่น Windows (จนถึงพฤศจิกายน 2014) ซึ่งประเภทของ VM สามารถทำงานบน windows, Linux และ Mac

นี่คือรูปจากนักเทียบท่า / สิทธิ์:

1. น้ำหนักเบา

นี่อาจเป็นความประทับใจครั้งแรกสำหรับผู้เรียนนักเทียบท่าจำนวนมาก

อย่างแรกรูปอิมเมจเทียบท่ามักจะเล็กกว่าอิมเมจ VM ทำให้ง่ายต่อการสร้างคัดลอกแชร์

ประการที่สองคอนเทนเนอร์ Docker สามารถเริ่มต้นในหลายมิลลิวินาทีในขณะที่ VM เริ่มในไม่กี่วินาที

2. ระบบไฟล์แบบเลเยอร์

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

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

3. เคอร์เนลระบบปฏิบัติการที่ใช้ร่วมกัน

คิดว่าคอนเทนเนอร์เป็นกระบวนการ!

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

สิ่งนี้เป็นสิ่งที่ดีสำหรับกรณีส่วนใหญ่ (ไม่มีเคอร์เนลระบบปฏิบัติการพิเศษที่รักษาไว้) แต่อาจมีปัญหาหากจำเป็นต้องมีการแยกอย่างเข้มงวดระหว่างคอนเทนเนอร์

ทำไมมันถึงสำคัญ?

สิ่งเหล่านี้ดูเหมือนเป็นการปรับปรุงไม่ใช่การปฏิวัติ ดีนำไปสู่การสะสมเชิงปริมาณเพื่อการเปลี่ยนแปลงเชิงคุณภาพ

คิดถึงการปรับใช้แอปพลิเคชัน หากเราต้องการปรับใช้ซอฟต์แวร์ (บริการ) ใหม่หรืออัปเกรดหนึ่งควรเปลี่ยนไฟล์และกระบวนการปรับแต่งแทนการสร้าง VM ใหม่ เนื่องจากการสร้าง VM ด้วยบริการที่อัปเดตจึงทำการทดสอบ (แชร์ระหว่าง Dev & QA) การปรับใช้กับการผลิตใช้เวลาหลายชั่วโมงหรือหลายวัน หากมีสิ่งใดผิดพลาดคุณต้องเริ่มต้นใหม่อีกครั้งโดยเสียเวลามากขึ้น ดังนั้นให้ใช้เครื่องมือจัดการการกำหนดค่า (puppet, saltstack, chef ฯลฯ ) เพื่อติดตั้งซอฟต์แวร์ใหม่ดาวน์โหลดไฟล์ใหม่เป็นที่ต้องการ

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

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

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

ใน Docker คอนเทนเนอร์ที่ใช้งานร่วมกันจะใช้โฮสติ้งเคอร์เนลระบบปฏิบัติการในขณะที่ใน VM จะมีไฟล์ระบบปฏิบัติการของตัวเอง สภาพแวดล้อม (ระบบปฏิบัติการ) ที่คุณพัฒนาแอปพลิเคชันจะเหมือนกันเมื่อคุณปรับใช้กับสภาพแวดล้อมการให้บริการที่หลากหลายเช่น "การทดสอบ" หรือ "การผลิต"

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

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

ที่มา: https://azure.microsoft.com/en-us/blog/containers-docker-windows-and-trends/

มีการตั้งค่าสามแบบที่ให้สแต็กเพื่อเรียกใช้แอปพลิเคชัน (ซึ่งจะช่วยให้เรารับรู้ว่าคอนเทนเนอร์คืออะไรและอะไรทำให้มีประสิทธิภาพมากกว่าโซลูชันอื่น ๆ ):

1) Traditional Servers(bare metal)
2) Virtual machines (VMs)
3) Containers

1) เซิร์ฟเวอร์สแต็กดั้งเดิมประกอบด้วยฟิสิคัลเซิร์ฟเวอร์ที่รันระบบปฏิบัติการและแอปพลิเคชันของคุณ

ข้อดี:

• การใช้ประโยชน์จากทรัพยากรดิบ

• การแยกตัว

ข้อเสีย:

• เวลาการปรับใช้ช้ามาก
• เเพง
• ทรัพยากรที่สูญเปล่า
• ปรับขนาดได้ยาก
• โยกย้ายยาก
• การกำหนดค่าที่ซับซ้อน

2) VM stackประกอบด้วยเซิร์ฟเวอร์จริงที่รันระบบปฏิบัติการและไฮเปอร์ไวเซอร์ที่จัดการเครื่องเสมือนของคุณทรัพยากรที่ใช้ร่วมกันและอินเทอร์เฟซเครือข่าย Vm แต่ละเครื่องจะเรียกใช้ระบบปฏิบัติการ Guest ซึ่งเป็นแอพพลิเคชั่นหรือชุดของแอพพลิเคชั่น

ข้อดี:

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

ข้อเสีย:

• การจัดสรรทรัพยากรเป็นปัญหา
• ล็อคผู้ขาย
• การกำหนดค่าที่ซับซ้อน

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

ข้อดี:

• การแยกตัว
• มีน้ำหนักเบา
• ทรัพยากรที่มีประสิทธิภาพ
• ง่ายต่อการโยกย้าย
• ความปลอดภัย
• ค่าใช้จ่ายต่ำ
• การผลิตกระจกและสภาพแวดล้อมการพัฒนา

ข้อเสีย:

• สถาปัตยกรรมเดียวกัน
• แอพที่ใช้ทรัพยากรมาก
• ปัญหาเครือข่ายและความปลอดภัย

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

เกี่ยวข้องกับ: -

"ทำไมการปรับใช้ซอฟต์แวร์กับอิมเมจเทียบท่าง่ายกว่าการปรับใช้กับสภาพแวดล้อมการผลิตที่สอดคล้องกัน"

ซอฟต์แวร์ส่วนใหญ่มีการปรับใช้กับสภาพแวดล้อมต่าง ๆ โดยทั่วไปจะมีอย่างน้อยสามข้อต่อไปนี้:

1. พีซีสำหรับนักพัฒนาส่วนบุคคล
2. สภาพแวดล้อมของนักพัฒนาที่ใช้ร่วมกัน
3. พีซีส่วนบุคคล (s)
4. สภาพแวดล้อมการทดสอบที่ใช้ร่วมกัน
5. สภาพแวดล้อม QA
6. สภาพแวดล้อมเอือด
7. การทดสอบโหลด / ประสิทธิภาพ
8. การแสดงสด
9. การผลิต
10. เอกสารเก่า

นอกจากนี้ยังมีปัจจัยที่ควรพิจารณา:

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

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

ทั้งหมดนี้หมายความว่าการสร้างสภาพแวดล้อมที่สอดคล้องกันในสถานที่แรกนั้นยากพอเพียงเพราะปริมาณที่แท้จริง (แม้ในสถานการณ์ที่เป็นสีเขียว) แต่การทำให้พวกเขาสอดคล้องกันเป็นสิ่งที่เป็นไปไม่ได้ แต่ให้จำนวนเซิร์ฟเวอร์ที่สูงเพิ่มเซิร์ฟเวอร์ใหม่ ด้วยตนเอง), การอัปเดตอัตโนมัติจากผู้ขาย o / s, ผู้ขายแอนตี้ไวรัส, ผู้ขายเบราว์เซอร์และสิ่งที่คล้ายกัน, การติดตั้งซอฟต์แวร์ด้วยตนเองหรือการเปลี่ยนแปลงการกำหนดค่าที่ดำเนินการโดยนักพัฒนาหรือช่างเทคนิคเซิร์ฟเวอร์ ฯลฯ เพื่อรักษาสภาพแวดล้อมให้สอดคล้องกัน (โอเคสำหรับคนเจ้าระเบียบมันสามารถทำได้ แต่ต้องใช้เวลาจำนวนมากความพยายามและวินัยซึ่งเป็นเหตุผลที่แม่นยำว่าทำไม VMs และคอนเทนเนอร์ (เช่น Docker) ถูกออกแบบมาตั้งแต่แรก)

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

มีคำตอบมากมายที่อธิบายรายละเอียดเพิ่มเติมเกี่ยวกับความแตกต่าง แต่นี่คือคำอธิบายสั้น ๆ ของฉัน

หนึ่งความแตกต่างที่สำคัญคือว่าVMs ใช้เคอร์เนลที่แยกต่างหากเพื่อเรียกใช้ระบบปฏิบัติการ นั่นเป็นเหตุผลที่มันหนักและใช้เวลาในการบูตใช้ทรัพยากรระบบมากขึ้น

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

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

Docker ใช้ระบบไฟล์ UNION .. Docker ใช้เทคโนโลยี copy-on-write เพื่อลดพื้นที่หน่วยความจำที่ใช้โดยคอนเทนเนอร์ อ่านเพิ่มเติมได้ที่นี่

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

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

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

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

ที่มา: Kubernetes in Action

ฉันใช้ Docker ในสภาพแวดล้อมการใช้งานจริงและใช้งานจริงมาก เมื่อคุณคุ้นเคยกับมันคุณจะพบว่ามันมีประสิทธิภาพมากสำหรับการสร้างที่เก็บหลายและสภาพแวดล้อมที่แยกได้

นักเทียบท่าได้รับการพัฒนาบนพื้นฐานของ LXC (Linux Container) และทำงานได้อย่างสมบูรณ์แบบในการกระจาย Linux จำนวนมากโดยเฉพาะอูบุนตู

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

นอกจากนั้นยังมีน้ำหนักเบาและมีความยืดหยุ่นเนื่องจากการกำหนดค่า dockerFile

ตัวอย่างเช่นคุณสามารถสร้างภาพ Docker และกำหนดค่า DockerFile และบอกว่าตัวอย่างเช่นเมื่อมันทำงานแล้ว wget 'this' apt-get 'that' เรียกใช้ 'เชลล์สคริปต์บางตัว' ตั้งค่าตัวแปรสภาพแวดล้อมและอื่น ๆ

ในโครงการขนาดเล็กและสถาปัตยกรรม Docker เป็นทรัพย์สินที่มีศักยภาพมาก คุณสามารถปรับขนาดความยืดหยุ่นและความยืดหยุ่นได้ด้วย Docker, Docker swarm, Kubernetes และ Docker Compose

ปัญหาที่สำคัญอีกประการเกี่ยวกับ Docker คือ Docker Hub และชุมชน ตัวอย่างเช่นฉันใช้ระบบนิเวศเพื่อตรวจสอบคาฟกาโดยใช้โพรเมเนส, Grafana, โพรเมเนส - JMX- ผู้ส่งออกและนักเทียบท่า

สำหรับการทำเช่นนั้นฉันดาวน์โหลดคอนเทนเนอร์ Docker ที่กำหนดค่าไว้สำหรับ zookeeper, kafka, Prometheus, Grafana และ jmx-collector แล้วติดตั้งการกำหนดค่าของตัวเองสำหรับบางคนโดยใช้ไฟล์ YAML หรือสำหรับคนอื่น ๆ ฉันเปลี่ยนไฟล์และการตั้งค่าในคอนเทนเนอร์ Docker แล้ว สร้างระบบทั้งหมดสำหรับการตรวจสอบคาฟคาโดยใช้ตัวเชื่อมต่อแบบหลายคอนเทนเนอร์บนเครื่องเดียวที่มีการแยกและการปรับขนาดและความยืดหยุ่นที่สถาปัตยกรรมนี้สามารถเคลื่อนย้ายไปยังเซิร์ฟเวอร์หลายเครื่องได้อย่างง่ายดาย

นอกเหนือจากไซต์ Docker Hub แล้วยังมีไซต์อื่นที่เรียกว่า quay.io ที่คุณสามารถใช้เพื่อให้แดชบอร์ดรูปภาพ Docker ของคุณเองมีและดึง / ดันไปยัง / จากมัน คุณยังสามารถนำเข้ารูปภาพ Docker จาก Docker Hub ไปยังท่าเรือจากนั้นเรียกใช้รูปภาพเหล่านี้จาก quay บนเครื่องของคุณเอง

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

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

นี่คือวิธีที่นักแนะนำตัวเอง:

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

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

หากคุณเข้าใจคอนเทนเนอร์คุณจะได้รับ Docker คืออะไรและแตกต่างจากVMอย่างไร ...

ดังนั้นคอนเทนเนอร์คืออะไร

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

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

มีคำตอบทางเทคนิคที่ดีมากมายที่นี่ซึ่งพูดถึงความแตกต่างระหว่าง VMs และคอนเทนเนอร์รวมถึงต้นกำเนิดของ Docker อย่างชัดเจน

สำหรับฉันความแตกต่างพื้นฐานระหว่าง VM และ Docker คือวิธีที่คุณจัดการโปรโมตแอปพลิเคชันของคุณ

ด้วย VMs คุณส่งเสริมแอปพลิเคชันของคุณและการพึ่งพาจาก VM หนึ่งไปยัง DEV ถัดไปเป็น UAT ถึง PRD

1. บ่อยครั้งที่ VM เหล่านี้จะมีแพตช์และไลบรารีต่างกัน
2. ไม่ใช่เรื่องแปลกสำหรับแอปพลิเคชั่นหลายตัวที่จะแชร์ VM สิ่งนี้ต้องการการจัดการการกำหนดค่าและการอ้างอิงสำหรับแอปพลิเคชันทั้งหมด
3. Backout ต้องการการเลิกทำการเปลี่ยนแปลงใน VM หรือเรียกคืนได้ถ้าเป็นไปได้

ด้วย Docker แนวคิดก็คือคุณรวมแอปพลิเคชันของคุณไว้ในคอนเทนเนอร์ของตัวเองพร้อมกับไลบรารี่ที่มันต้องการแล้วโปรโมตคอนเทนเนอร์ทั้งหมดเป็นหน่วยเดียว

1. ยกเว้นเคอร์เนลแพตช์และไลบรารีเหมือนกัน
2. ตามกฎทั่วไปมีเพียงแอปพลิเคชันเดียวต่อคอนเทนเนอร์ซึ่งทำให้การกำหนดค่าง่ายขึ้น
3. Backout ประกอบด้วยการหยุดและการลบคอนเทนเนอร์

ดังนั้นในระดับพื้นฐานที่สุดด้วย VM คุณส่งเสริมแอปพลิเคชั่นและการพึ่งพาเป็นองค์ประกอบที่ไม่ต่อเนื่องในขณะที่ด้วย Docker คุณส่งเสริมทุกอย่างในการเข้าชมครั้งเดียว

และใช่มีปัญหาเกี่ยวกับคอนเทนเนอร์รวมถึงการจัดการแม้ว่าเครื่องมืออย่าง Kubernetes หรือ Docker Swarm จะทำให้งานง่ายขึ้นมาก