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

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

ทำไมต้อง Qemu-KVM? สำหรับ Linux นี่เป็นโปรเจ็กต์การจำลองเสมือนที่แนะนำมากที่สุด มันทำงานได้เร็วกว่า VirtualBoxและ วีเอ็มแวร์ เพลเยอร์(ตามการทดสอบของฉัน) KVM เป็นเทคโนโลยีดั้งเดิมสำหรับ Linux นอกจากนี้ หากคุณมีคอมพิวเตอร์สำหรับเล่นเกมที่ดีซึ่งมีการ์ดแสดงผลสองตัว คุณสามารถติดตั้งใน Qemu-KVM ได้ หน้าต่างโยนการ์ดแสดงผลตัวใดตัวหนึ่งลงไปแล้วลืมการรีบูตระบบปฏิบัติการอื่น หากคุณต้องการเล่นคุณเปิดเครื่องเสมือนด้วย Windows และเล่น ประสิทธิภาพจะเป็น 95% ของประสิทธิภาพของ Windows ที่ติดตั้งบนฮาร์ดแวร์ แต่มันก็งดงามมากในความคิดของฉัน ฉันจะเขียนบทความแยกต่างหากเกี่ยวกับเรื่องนี้ มันจะน่าสนใจ :)

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

• ติดตั้ง qemu-kvm;
• การติดตั้งตัวจัดการกราฟิกและยูทิลิตี้เพิ่มเติม
• การตั้งค่าสะพานเครือข่าย
• การสร้างที่เก็บข้อมูลสำหรับเครื่องเสมือน
• การติดตั้งระบบแขก

ขั้นแรก ตรวจสอบว่าคอมพิวเตอร์ของคุณรองรับการจำลองเสมือนสำหรับฮาร์ดแวร์หรือไม่ หากต้องการทำสิ่งนี้ ให้รันคำสั่งในเทอร์มินัล:

egrep "(vmx|svm)" /proc/cpuinfo

เอาต์พุตคำสั่งจะต้องมีอย่างใดอย่างหนึ่ง วีเอ็มเอ็กซ์, หรือ เอสวีเอ็ม- หากไม่มี ให้ตรวจสอบว่าเปิดใช้งานการจำลองเสมือนใน BIOS หรือไม่ (มองหารายการ Intel VT-iหรือคล้ายกันสำหรับ เอเอ็มดี- หากไม่มีสิ่งใดเลยแสดงว่าคุณไม่มีโชค

ติดตั้งส่วนประกอบที่จำเป็น:

sudo apt ติดตั้ง qemu-kvm bridge-utils libvirt-bin virt-manager

เพิ่มตัวคุณเองในกลุ่ม libvirt:

sudo adduser $USER libvirt

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

sudo นาโน /etc/sysctl.conf

เรามองหาบรรทัด net.ipv4_forward=0 และเปลี่ยนค่าเป็น 1 - เรายังบันทึก:

sudo sysctl -p

ต่อไปฉันจะถือว่าสิ่งต่อไปนี้: 1) บนคอมพิวเตอร์ของคุณมีการ์ดเครือข่ายหนึ่งการ์ดที่รับที่อยู่ IP จากเราเตอร์ 2) คุณเข้าถึงอินเทอร์เน็ตผ่านโมเด็ม 3G และการ์ดเครือข่ายของคุณฟรี ตัวเลือกนี้เกี่ยวข้องกับการทำงานด้วยตนเองมากขึ้น แต่มีการทดสอบหลายครั้ง (ฉันทำสิ่งนี้ด้วยตัวเองในเครื่องเครื่องใดเครื่องหนึ่ง) ดังนั้นให้เปิดไฟล์อินเทอร์เฟซ:

sudo nano /etc/network/interfaces

เนื้อหาเริ่มต้นคือ:

อัตโนมัติแท้จริง
iface หรือ inet loopback

เราเปลี่ยนเนื้อหา สำหรับตัวเลือกแรก:

แหล่งที่มา /etc/network/interfaces.d/*

# อินเทอร์เฟซเครือข่ายแบบย้อนกลับ
อัตโนมัติแท้จริง
iface หรือ inet loopback

อัตโนมัติ eth0
คู่มือ iface eth0 inet

อัตโนมัติ br0
iface br0 inet คงที่
ที่อยู่ 192.168.0.2
เกตเวย์ 192.168.0.1
เน็ตมาสก์ 255.255.255.0
เครือข่าย 192.168.0.0
ออกอากาศ 192.168.0.255
bridge_ports eth0
ปิด bridge_stp
bridge_maxwait 0
สะพาน_fd 0

สำหรับตัวเลือกที่สอง:

แหล่งที่มา /etc/network/interfaces.d/*

# อินเทอร์เฟซเครือข่ายแบบย้อนกลับ
อัตโนมัติแท้จริง
iface หรือ inet loopback

อัตโนมัติ ppp0
iface ppp0 inet wvdial

อัตโนมัติ eth0
คู่มือ iface eth0 inet

อัตโนมัติ br0
iface br0 inet คงที่
ที่อยู่ 192.168.0.2
เกตเวย์ 192.168.0.1
เน็ตมาสก์ 255.255.255.0
เครือข่าย 192.168.0.0
ออกอากาศ 192.168.0.255
bridge_ports eth0
ปิด bridge_stp
bridge_maxwait 0
สะพาน_fd 0
ขึ้นเส้นทางเดลค่าเริ่มต้น br0

บันทึก:หากคุณไม่ต้องการการเชื่อมต่ออินเทอร์เน็ตอัตโนมัติผ่านโมเด็มหลังจากที่ระบบเริ่มทำงาน ให้ลบบรรทัด auto ppp0 และ
iface ppp0 inet wvdial มิฉะนั้น ตรวจสอบให้แน่ใจว่าเมื่อระบบเริ่มทำงาน โมเด็มได้เสียบเข้ากับพอร์ต USB แล้ว

บันทึก. ตอนนี้สำหรับตัวเลือกที่มีโมเด็มคุณต้องติดตั้งโปรแกรมตัวโทรออก wvdial:

sudo apt ติดตั้ง wvdial

การแก้ไขการกำหนดค่า (หมายเหตุ: ใช้โมเด็ม 3G เป็นตัวอย่าง เส้นตรง- คุณสามารถค้นหาตัวอย่างการกำหนดค่าสำหรับโมเด็มอื่น ๆ บนอินเทอร์เน็ตได้อย่างง่ายดาย:

sudo นาโน /etc/wvdial.conf

เริ่มต้น 1 = ATZ
เริ่มต้น2 = ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0
Init3 = AT+CGDCONT=1,"IP", "home.beeline.ru"
โหมดโง่ = 1
ISDN = 0
ประเภทโมเด็ม = โมเด็ม USB
ใหม่ PPPD = ใช่
โทรศัพท์ = *99#
โมเด็ม = /dev/ttyACM0
ชื่อผู้ใช้ = เส้นตรง
รหัสผ่าน = เส้นตรง
บอด = 9600
ประเทศ = รัสเซีย
เชื่อมต่อใหม่อัตโนมัติ=เปิด
DNS อัตโนมัติ = ปิด
วินาทีที่ไม่ได้ใช้งาน = 0

บันทึก. ตอนนี้โมเด็มจะเปิดทันทีหลังจากที่ระบบบูท เส้นทางการเรียงแถว del default br0 จะลบเส้นทางเริ่มต้นผ่านสะพาน หากคุณไม่ทำเช่นนี้ คุณจะไม่สามารถเชื่อมต่ออินเทอร์เน็ตได้ เนื่องจากการรับส่งข้อมูลจะข้ามบริดจ์และไม่ผ่านโมเด็ม 3G

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

#!/bin/sh

# กำหนดอินเทอร์เฟซเอาต์พุตที่จะใช้การแทนที่ที่อยู่ (NAT)
iptables -v -t nat -A การโพสต์ -o ppp0 -j MASQUERADE

# เราส่งต่อแพ็กเก็ตทั้งหมดที่ได้รับจากโมเด็มจากเครือข่ายทั่วโลก (0.0.0.0/0) ไปยังเครือข่ายท้องถิ่น (192.168.0.0/24)
iptables -v -A ส่งต่อ -i ppp0 -o br0 -s 0.0.0.0/0 -d 192.168.0.0/24 -j ยอมรับ

# ส่งต่อแพ็คเก็ตทั้งหมดที่มาจากเครือข่ายท้องถิ่น (192.168.0.0/24) ไปยังระดับโลก (0.0.0.0/0)
iptables -v -A ส่งต่อ -i br0 -o ppp0 -s 192.168.0.0/24 -d 0.0.0.0/0 -j ยอมรับ

บันทึกเป็น เกตเวย์.ชและให้สิทธิ์ในการดำเนินการ (ไม่ว่าจะในคุณสมบัติไฟล์หรือในเทอร์มินัลด้วยคำสั่ง chmod +x เกตเวย์.sh- ตอนนี้คุณสามารถเปิดใช้งานได้ด้วยตนเองหลังจากที่ระบบบูตแล้วหรือเพิ่มลงในการเริ่มต้นระบบ เมื่อต้องการทำเช่นนี้ ให้ย้ายสคริปต์ไปที่ ~/.config/เริ่มอัตโนมัติ(ในตัวจัดการไฟล์ ให้เปิดแสดงไฟล์ที่ซ่อนแล้วคุณจะเห็นไดเร็กทอรี .กำหนดค่าในโฮมไดเร็กตอรี่ของคุณ)

ตอนนี้ทุกอย่างก็พร้อมที่จะติดตั้งเครื่องเสมือนแล้ว จากเมนูแอปพลิเคชัน เปิด Virt Manager (ตัวจัดการเครื่องเสมือน):

คลิกขวาที่บรรทัด โลคัลโฮสต์และเลือก รายละเอียด- ไปที่แท็บ พื้นที่จัดเก็บ- เราจำเป็นต้องระบุไดเรกทอรี (หรือพาร์ติชันดิสก์/ดิสก์) เพื่อจัดเก็บเครื่องเสมือน

ที่มุมซ้ายล่าง ให้คลิกเครื่องหมายบวก ( เพิ่มสระน้ำ) ระบุประเภทของที่เก็บข้อมูลและเส้นทางไป

บนแท็บ อินเทอร์เฟซเครือข่ายคุณสามารถตรวจสอบว่าทุกอย่างใช้งานได้หรือไม่

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

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

ถัดจากแท็บ สุทธิ(ถัดไป) และยังระบุด้วย วิทิโอ- บนแท็บ แสดงโปรดระบุ เครื่องเทศและบนแท็บ วีดีโอ - คิวเอ็กซ์แอล- โดยปกติแล้วการรวมกันนี้จะให้ประสิทธิภาพการเรนเดอร์กราฟิกสูงสุด แต่คุณสามารถทดลองได้หากต้องการ โปรดทราบว่าสำหรับระบบ Windows guest จำเป็นต้องมีการติดตั้งไดรเวอร์ QXL แยกต่างหาก (ใน Windows เอง)

เมื่อทุกอย่างพร้อมแล้ว ให้คลิก ที่มุมซ้ายบน เริ่มการติดตั้ง- และติดตั้งระบบตามปกติ โดยมีข้อยกเว้นประการหนึ่ง: ทันทีที่ตัวติดตั้งเริ่มกำหนดค่าเครือข่ายโดยอัตโนมัติ ให้คลิก ยกเลิกและเลือก กำหนดค่าเครือข่ายด้วยตนเอง- ระบุที่อยู่ IP ที่ต้องการสำหรับเครื่องเสมือน (ในกรณีของเรา 192.168.0.3 ) ซับเน็ตมาสก์ ( 255.255.255.0 ) เกตเวย์ (เกตเวย์จะเป็นที่อยู่โฮสต์นั่นคือ 192.168.0.2 ) และเซิร์ฟเวอร์ DNS (ในที่นี้ระบุเฉพาะ Google 8.8.8.8 - นั่นคือทั้งหมดที่ ไม่จำเป็นต้องทำอะไรเพิ่มเติม ติดตั้งระบบและกำหนดค่า โดยทั่วไปนั่นคือทั้งหมด ขั้นตอนที่อธิบายไว้เป็นวิธีแทนที่ VirtualBox ด้วยทางเลือกที่ดีกว่า หลังจากอ่านเอกสารแล้ว คุณจะเข้าใจว่าความสามารถของ Qemu-KVM นั้นกว้างแค่ไหน ฉันไม่ได้ตั้งใจอธิบายพารามิเตอร์คอนโซลเพิ่มเติมและวิธีการเรียกใช้เครื่องเสมือนผ่านเทอร์มินัลที่นี่เนื่องจากไม่จำเป็นเสมอไปสำหรับเครื่องที่บ้าน ฉันจะเขียนบทความแยกต่างหากเกี่ยวกับเรื่องนี้ในการตั้งค่าเซิร์ฟเวอร์มัลติฟังก์ชั่นที่บ้าน (ซึ่งสามารถทำหน้าที่เป็นเซิร์ฟเวอร์เครื่องเสมือนได้) สำหรับผู้ที่ไม่เข้าใจสิ่งที่เขียนด้วยเหตุผลบางอย่างหรือยังมีช่วงเวลาที่ไม่ชัดเจน ฉันขอแนะนำให้ดูวิดีโอที่ฉันจะไม่อธิบาย แต่จะแสดงวิธีการติดตั้งและกำหนดค่าสิ่งเหล่านี้ทั้งหมด หากคุณมีข้อเสนอแนะหรือเพิ่มเติมในบทความ โปรดเขียนความคิดเห็น

ในฐานะผู้ชื่นชอบ Linux ฉันตรวจสอบแอปพลิเคชันและการแจกจ่าย Open Source และ Linux จำนวนมากทุกวัน ฉันใช้ Oracle VirtualBox เป็นหลักเพื่อทดสอบและสร้างระบบปฏิบัติการต่างๆ ขึ้นมาใหม่ VirtualBox เป็นเครื่องมือการจำลองเสมือนยอดนิยมสำหรับการปรับใช้หรือทดสอบการแจกแจงประเภทต่างๆ เช่นเดียวกับ Oracle VirtualBox มีผลิตภัณฑ์เสมือนจริงมากมาย เช่น , OpenVZ, KVM, Proxmox เป็นต้น วันนี้เราจะมาหารือเกี่ยวกับ QEMU

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

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

เมื่อใช้เป็นเวอร์ชวลไลเซอร์ QEMU จะได้รับประสิทธิภาพที่คล้ายกันมากโดยการรันโค้ดเกสต์บนโปรเซสเซอร์โฮสต์โดยตรง QEMU รองรับการจำลองเสมือนเมื่อทำงานภายใต้ไฮเปอร์ไวเซอร์ Xen หรือใช้โมดูลเคอร์เนล KVM บน Linux

QEMU มีสองโหมดการทำงาน:

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

QEMU สามารถทำงานได้โดยไม่ต้องใช้ไดรเวอร์โฮสต์เคอร์เนล และยังคงให้ประสิทธิภาพที่ยอมรับได้

ติดตั้ง QEMU บน Ubuntu 16.04

ในตัวอย่างนี้ เรามาดูวิธีการติดตั้งและกำหนดค่า QEMU บน Ubuntu 16.04 LTS รวมถึงวิธีสร้างและจัดการเครื่องเสมือน

QEMU มีให้ใช้งานได้ตามค่าเริ่มต้นในที่เก็บ Ubuntu ดังนั้นเราจึงสามารถติดตั้งด้วยเครื่องมือ Virt Manager โดยใช้คำสั่ง:

Sudo apt ติดตั้ง qemu-kvm qemu qemu-system virt-manager virt-viewer libvirt-bin

หลังจากติดตั้งแพ็คเกจข้างต้นแล้ว ให้รีบูทระบบ

การสร้างเครื่องเสมือน

ตอนนี้เรามาสร้างเครื่องเสมือนใหม่กันดีกว่า

ขั้นแรกคุณต้องสร้างอิมเมจฮาร์ดดิสก์เสมือนสำหรับเครื่องเสมือนใหม่ ตัวอย่างเช่น เรามาสร้างอิมเมจฮาร์ดไดรฟ์ขนาด 20GB กัน

Qemu-img สร้าง ubuntu.img 20G

จากนั้นดาวน์โหลดอิมเมจการติดตั้งเซิร์ฟเวอร์ Ubuntu 15.04 จากเว็บไซต์อย่างเป็นทางการ

หากต้องการบูตเครื่องเสมือน ให้รันคำสั่งต่อไปนี้:

สำหรับระบบ 64 บิต

Qemu-system-x86_64 -hda ubuntu.img -boot d -cdrom /home/linuxthebest/ดาวน์โหลด/ubuntu-15.04-server-i386.iso -m 1024

สำหรับระบบ 32 บิต

Qemu-system-i386 -hda ubuntu.img -boot d -cdrom /home/linuxthebest/Downloads/ubuntu-15.04-server-amd64.iso -m 1024

โดยที่ “/home/linuxthebest/Downloads/ubuntu-15.04-server-i386.iso” คือไดเร็กทอรีที่ดาวน์โหลดอิมเมจ และ 1024 คือขนาดของ RAM ที่จัดสรรสำหรับเครื่อง

เมื่อบูตเครื่องหน้าจอการติดตั้งจะปรากฏขึ้น กด Enter และทำการติดตั้งต่อตามปกติ

หลังจากการติดตั้งเสร็จสมบูรณ์ สามารถบูตระบบได้โดยใช้คำสั่ง:

Qemu -hda ubuntu.img -m 1,024

นั่นคือทั้งหมดที่

ไม่ชอบบรรทัดคำสั่งใช่ไหม การสร้างและการจัดการเครื่องเสมือนจากบรรทัดคำสั่งอาจเป็นเรื่องยากสำหรับผู้ใช้บางราย ไม่ต้องกังวล เรายังสามารถสร้างเครื่องเสมือนโดยใช้เครื่องมือ GUI ที่เรียกว่าได้ ตัวจัดการเครื่องเสมือน (Virt Manager).

หากคุณยังไม่เคยติดตั้งมาก่อน คุณสามารถติดตั้งได้โดยใช้คำสั่ง

Sudo apt ติดตั้ง virt-manager qemu-system libvirt-bin

สร้างและจัดการเครื่องเสมือนโดยใช้ Virt Manager

เปิดตัวจัดการเครื่องเสมือน

Sudo virt-ผู้จัดการ

ตามค่าเริ่มต้น อินเทอร์เฟซ Virt Manager จะมีลักษณะดังนี้

ตอนนี้เราจะสร้างและติดตั้ง Ubuntu 16.10 บนเครื่องเสมือน

หากต้องการสร้างเครื่องเสมือน ให้ไปที่ไฟล์ -> เครื่องเสมือนใหม่

เลือกระบบปฏิบัติการที่คุณต้องการติดตั้ง

คุณสามารถติดตั้ง guest OS ได้โดยใช้อิมเมจ ISO/CD-ROM ในเครื่อง การติดตั้งเครือข่าย เซิร์ฟเวอร์ PXE หรือนำเข้าดิสก์อิมเมจที่มีอยู่ นอกจากนี้ คุณสามารถเลือกสถาปัตยกรรมระบบปฏิบัติการเกสต์ได้จากตัวเลือกขั้นสูง

เลือกจำนวน RAM และโปรเซสเซอร์

ป้อนขนาดฮาร์ดดิสก์เสมือนของคุณ ค่าเริ่มต้นคือ 8GB

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

หลังจากคลิกปุ่มเสร็จสิ้น guest OS จะเริ่มโหลดโดยอัตโนมัติ

นั่นคือทั้งหมดที่ ตอนนี้ให้ติดตั้ง guest OS เช่นเดียวกับที่คุณทำบนระบบปกติ

ฉันติดตั้ง Ubuntu 16.10 ใน virt manager และอีกอย่าง unity 8 ทำงานที่นั่น เมื่อเทียบกับ virtualbox ซึ่งมันใช้งานไม่ได้ ดังนั้นหากคุณต้องการทดสอบสภาพแวดล้อมการทำงานใหม่ คุณสามารถติดตั้ง virt manager และเรียกใช้ unity 8 ที่นั่นได้ .

โดยส่วนตัวแล้ว มันง่ายที่สุดสำหรับฉันที่จะนึกถึง KVM (เครื่องเสมือนที่ใช้เคอร์เนล) ว่าเป็นระดับนามธรรมเหนือเทคโนโลยีการจำลองเสมือนสำหรับฮาร์ดแวร์ Intel VT-x และ AMD-V เราใช้เครื่องที่มีโปรเซสเซอร์ที่รองรับหนึ่งในเทคโนโลยีเหล่านี้ ติดตั้ง Linux บนเครื่องนี้ ติดตั้ง KVM ใน Linux และด้วยเหตุนี้ เราจึงได้รับโอกาสในการสร้างเครื่องเสมือน นี่คือวิธีการทำงานของคลาวด์โฮสติ้งโดยประมาณ เช่น Amazon Web Services นอกเหนือจาก KVM แล้ว บางครั้งยังใช้ Xen ด้วย แต่การสนทนาเกี่ยวกับเทคโนโลยีนี้อยู่นอกเหนือขอบเขตของโพสต์นี้ ต่างจากเทคโนโลยีการจำลองเสมือนของคอนเทนเนอร์ เช่น Docker KVM อนุญาตให้คุณเรียกใช้ระบบปฏิบัติการใด ๆ ในฐานะระบบเกสต์ แต่ก็มี โอค่าใช้จ่ายที่สูงขึ้นสำหรับการจำลองเสมือน

บันทึก:ขั้นตอนที่อธิบายด้านล่างนี้ได้รับการทดสอบโดยฉันบน Ubuntu Linux 14.04 แต่ตามทฤษฎีแล้วจะใช้ได้กับทั้ง Ubuntu เวอร์ชันอื่นและ Linux อื่น ๆ ทุกอย่างควรทำงานได้ทั้งบนเดสก์ท็อปและบนเซิร์ฟเวอร์ที่เข้าถึงได้ผ่าน SSH

การติดตั้ง KVM

เราตรวจสอบว่าโปรเซสเซอร์ของเรารองรับ Intel VT-x หรือ AMD-V หรือไม่:

grep -E "(vmx|svm)" /proc/cpuinfo

หากมีสิ่งใดร้อนขึ้น แสดงว่าได้รับการรองรับ และคุณก็สามารถเดินหน้าต่อไปได้

การติดตั้ง KVM:

อัปเดต sudo apt-get
sudo apt-get ติดตั้ง qemu-kvm libvirt-bin virtinst bridge-utils

โดยปกติจะจัดเก็บอะไรไว้ที่:

• /var/lib/libvirt/boot/ - อิมเมจ ISO สำหรับการติดตั้งระบบเกสต์
• /var/lib/libvirt/images/ — รูปภาพของฮาร์ดไดรฟ์ของระบบแขก
• /var/log/libvirt/ - คุณควรมองหาบันทึกทั้งหมดที่นี่
• /etc/libvirt/ - ไดเร็กทอรีพร้อมไฟล์คอนฟิกูเรชัน;

เมื่อติดตั้ง KVM แล้ว มาสร้างเครื่องเสมือนเครื่องแรกของเรากันดีกว่า

การสร้างเครื่องเสมือนเครื่องแรก

ฉันเลือก FreeBSD เป็นระบบแขก ดาวน์โหลดอิมเมจ ISO ของระบบ:

ซีดี /var/lib/libvirt/boot/
sudo wget http:// ftp.freebsd.org/ เส้นทาง/ ถึง/ some-freebsd-disk.iso

เครื่องเสมือนได้รับการจัดการในกรณีส่วนใหญ่โดยใช้ยูทิลิตี้ virsh:

sudo virsh --help

ก่อนที่จะเปิดตัวเครื่องเสมือน เราจะต้องรวบรวมข้อมูลเพิ่มเติมบางอย่าง

เราดูรายการเครือข่ายที่มีอยู่:

sudo virsh net-list

ดูข้อมูลเกี่ยวกับเครือข่ายเฉพาะ (ตั้งชื่อเป็นค่าเริ่มต้น):

sudo virsh net-info เป็นค่าเริ่มต้น

ลองดูรายการการปรับให้เหมาะสมสำหรับระบบปฏิบัติการของแขก:

sudo virt-install --os-variant รายการ

ตอนนี้เราสร้างเครื่องเสมือนที่มี 1 CPU, RAM 1 GB และพื้นที่ดิสก์ 32 GB ซึ่งเชื่อมต่อกับเครือข่ายเริ่มต้น:

sudo virt-ติดตั้ง\
--virt-type = kvm \
--ชื่อ freebsd10\
--แรม 1024\
--vcpus=1\
--os-variant =freebsd8 \
--hvm\
--cdrom =/ var/ lib/ libvirt/ boot/ FreeBSD-10.2 -RELEASE-amd64-disc1.iso \
--เครือข่ายเครือข่าย =ค่าเริ่มต้น รุ่น =virtio \
--กราฟิก vnc\
--disk path =/ var/ lib/ libvirt/images/ freebsd10.img,size =32 ,bus =virtio

คุณสามารถดู:

คำเตือน ไม่สามารถเชื่อมต่อกับคอนโซลกราฟิกได้: virt-viewer ไม่ใช่
ติดตั้งแล้ว กรุณาติดตั้งแพ็คเกจ "virt-viewer"

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

นี่เป็นเรื่องปกติ นี่คือวิธีที่มันควรจะเป็น

จากนั้นดูคุณสมบัติของเครื่องเสมือนในรูปแบบ XML:

sudo virsh dumpxml ฟรีbsd10

ข้อมูลที่สมบูรณ์ที่สุดมีให้ไว้ที่นี่ ซึ่งรวมถึงที่อยู่ MAC ซึ่งเราจะต้องใช้ในภายหลัง ขณะนี้เรากำลังค้นหาข้อมูลเกี่ยวกับ VNC ในกรณีของฉัน:

ด้วยไคลเอนต์ที่คุณชื่นชอบ (ฉันใช้ Ramina เป็นการส่วนตัว) เราเข้าสู่ระบบผ่าน VNC โดยใช้การส่งต่อพอร์ต SSH หากจำเป็น เราเข้าสู่โปรแกรมติดตั้ง FreeBSD ทันที จากนั้นทุกอย่างก็เป็นไปตามปกติ - ถัดไป, ถัดไป, ถัดไป เราจะได้ระบบที่ติดตั้ง

คำสั่งพื้นฐาน

ตอนนี้เรามาดูคำสั่งพื้นฐานสำหรับการทำงานกับ KVM

รับรายการเครื่องเสมือนทั้งหมด:

รายการ sudo virsh --all

การรับข้อมูลเกี่ยวกับเครื่องเสมือนเฉพาะ:

sudo virsh dominfo ฟรี bsd10

เปิดตัวเครื่องเสมือน:

sudo virsh เริ่ม freebsd10

หยุดเครื่องเสมือน:

sudo virsh ปิดเครื่อง freebsd10

แทบจะตอกย้ำเครื่องเสมือน (แม้จะชื่อนี้ก็ตาม ไม่การลบ):

sudo virsh ทำลาย freebsd10

รีบูทเครื่องเสมือน:

sudo virsh รีบูต freebsd10

โคลนเครื่องเสมือน:

sudo virt-clone -o freebsd10 -n freebsd10-clone \
--file /var/lib/libvirt/images/freebsd10-clone.img

เปิด/ปิดการทำงานอัตโนมัติ:

sudo virsh เริ่มอัตโนมัติ freebsd10
sudo virsh เริ่มอัตโนมัติ -- ปิดการใช้งาน freebsd10

การรัน virsh ในโหมดไดอะล็อก (คำสั่งทั้งหมดในโหมดไดอะล็อก - ตามที่อธิบายไว้ข้างต้น):

ซูโด เวอร์ช

การแก้ไขคุณสมบัติของเครื่องเสมือนในรูปแบบ XML รวมถึงที่นี่คุณสามารถเปลี่ยนขีด จำกัด ของจำนวนหน่วยความจำ ฯลฯ :

sudo virsh แก้ไข freebsd10

สำคัญ!ความคิดเห็นจาก XML ที่แก้ไขถูกลบออกอย่างน่าเสียดาย

เมื่อเครื่องเสมือนหยุดทำงาน ดิสก์ยังสามารถปรับขนาดได้:

sudo qemu-img ปรับขนาด /var/ lib/ libvirt/ image/ freebsd10.img -2G
ข้อมูล sudo qemu-img /var/lib/libvirt/images/freebsd10.img

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

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

การตั้งค่าเครือข่าย

คำถามที่น่าสนใจ - จะทราบที่อยู่ IP ใดที่เครื่องเสมือนได้รับหลังจากโหลดได้อย่างไร KVM ทำสิ่งนี้ด้วยวิธีที่ชาญฉลาด ฉันลงเอยด้วยการเขียนสคริปต์นี้ใน Python:

#!/usr/bin/env python3

# สคริปต์ virt-ip.py
# (c) 2016 อเล็กซานเดอร์ อเล็กเซเยฟ
# http://site/

ระบบนำเข้า
นำเข้าอีกครั้ง
นำเข้าระบบปฏิบัติการ
กระบวนการย่อยการนำเข้า
จาก xml .etree นำเข้า ElementTree

def eprint(str) :
พิมพ์ (str, ไฟล์ = sys.stderr)

ถ้าเลน (sys.argv)< 2 :
eprint ("การใช้งาน: " + sys .argv [ 0 ] + " " )
eprint("ตัวอย่าง: " + sys .argv [ 0 ] + " freebsd10" )
sys.ออก(1)

ถ้า os .geteuid() != 0 :
eprint("ข้อผิดพลาด: คุณควรเป็น root")
eprint("คำแนะนำ: run `sudo " + sys .argv [ 0 ] + " ...`" ) ;
sys.ออก(1)

ถ้าประมวลผลย่อย .call ( "ซึ่ง arping 2>&1 >/dev/null", เชลล์ = จริง ) != 0 :
eprint("ข้อผิดพลาด: ไม่พบ arping")
พิมพ์( "คำแนะนำ: เรียกใช้ `sudo apt-get install arping`")
sys.ออก(1)

โดเมน = sys.argv[1]

หากไม่ใช่ .match อีกครั้ง ("^*$" , โดเมน) :
พิมพ์( "ข้อผิดพลาด: อักขระที่ไม่ถูกต้องในชื่อโดเมน")
sys.ออก(1)

Domout = กระบวนการย่อย .check_output ("virsh dumpxml " +domain+" || true" ,
เปลือก = จริง)
domout = domout.decode("utf-8").strip()

ถ้า domout == "" :
# ข้อความแสดงข้อผิดพลาดพิมพ์โดย dumpxml แล้ว
sys.ออก(1)

Doc = ElementTree.fromstring (domout)

# 1. แสดงรายการอินเทอร์เฟซเครือข่ายทั้งหมด
# 2. เรียกใช้ `arping` ในทุกอินเทอร์เฟซแบบขนาน
#3.grep ตอบกลับ
คำสั่ง = "(ifconfig | cut -d " " -f 1 | grep -E "." | " + \
"xargs -P0 -I IFACE arping -i IFACE -c 1 () 2>&1 | " + \
"grep "ไบต์จาก") || จริง"

สำหรับเด็กใน doc.iter() :
ถ้า child.tag == "mac" :
macaddr = child.attrib["ที่อยู่"]
macout = กระบวนการย่อย .check_output (cmd .format (macaddr) ,
เปลือก = จริง)
พิมพ์ (macout.decode ("utf-8"))

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

sudo virsh net-edit ค่าเริ่มต้น

... บางอย่างเช่นนี้:

>



>

หลังจากทำการเปลี่ยนแปลงเหล่านี้แล้ว


>

... และแทนที่ด้วยสิ่งที่ชอบ:

>

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

โปรแกรม virt-manager

คุณอาจสนใจโปรแกรม virt-manager:

sudo apt-get ติดตั้ง virt-manager
sudo usermod -a -G libvirtd ชื่อผู้ใช้

นี่คือลักษณะของหน้าต่างหลัก:

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

ด้วยความช่วยเหลือจาก virt-manager ทำให้สะดวกมากในการทำสิ่งต่าง ๆ ที่ต้องใช้การแก้ไขไฟล์ XML ที่ใช้แรงงานเข้มข้น และในบางกรณี การดำเนินการคำสั่งเพิ่มเติม ตัวอย่างเช่น การเปลี่ยนชื่อเครื่องเสมือน การตั้งค่าความสัมพันธ์ของ CPU และสิ่งที่คล้ายกัน อย่างไรก็ตาม การใช้ความสัมพันธ์ของ CPU จะช่วยลดผลกระทบของเพื่อนบ้านที่มีเสียงดังและอิทธิพลของเครื่องเสมือนในระบบโฮสต์ได้อย่างมาก ใช้มันทุกครั้งที่เป็นไปได้

หากคุณตัดสินใจใช้ KVM แทน VirtualBox โปรดทราบว่าพวกเขาจะไม่สามารถแชร์การจำลองเสมือนสำหรับฮาร์ดแวร์ระหว่างกันได้ เพื่อให้ KVM ทำงานบนเดสก์ท็อปของคุณ คุณไม่เพียงต้องหยุดเครื่องเสมือนทั้งหมดใน VirtualBox และ Vagrant เท่านั้น แต่ยังต้องรีบูทระบบด้วย โดยส่วนตัวแล้วฉันพบว่า KVM สะดวกกว่า VirtualBox มาก อย่างน้อยก็เพราะมันไม่ต้องการให้คุณเรียกใช้คำสั่ง การตั้งค่า sudo /sbin/rcvboxdrvหลังจากการอัปเดตเคอร์เนลแต่ละครั้ง มันจะทำงานร่วมกับ Unity ได้อย่างเพียงพอ และโดยทั่วไปจะอนุญาตให้คุณซ่อนหน้าต่างทั้งหมดได้

ใน Ubuntu ขอแนะนำให้ใช้ไฮเปอร์ไวเซอร์ KVM (ตัวจัดการเครื่องเสมือน) และไลบรารี libvirt เป็นเครื่องมือการจัดการ Libvirt ประกอบด้วยชุดซอฟต์แวร์ API และแอปพลิเคชันผู้ใช้สำหรับการจัดการเครื่องเสมือน (VM) virt-manager (อินเทอร์เฟซแบบกราฟิก, GUI) หรือ virsh (บรรทัดคำสั่ง, CLI) ในฐานะผู้จัดการทางเลือก คุณสามารถใช้ convirt (GUI) หรือ convirt2 (อินเทอร์เฟซเว็บ)

ปัจจุบันมีเพียงไฮเปอร์ไวเซอร์ KVM เท่านั้นที่ได้รับการสนับสนุนอย่างเป็นทางการบน Ubuntu ไฮเปอร์ไวเซอร์นี้เป็นส่วนหนึ่งของรหัสเคอร์เนลของระบบปฏิบัติการ Linux KVM ไม่รองรับ Paravirtualization ซึ่งแตกต่างจาก Xen ซึ่งหมายความว่า CPU ของคุณต้องรองรับเทคโนโลยี VT เพื่อใช้งาน คุณสามารถตรวจสอบว่าโปรเซสเซอร์ของคุณรองรับเทคโนโลยีนี้หรือไม่โดยการรันคำสั่งในเทอร์มินัล:

หากคุณได้รับข้อความต่อไปนี้:

ข้อมูล: /dev/kvm มีอยู่ สามารถใช้การเร่งความเร็ว KVM ได้

ซึ่งหมายความว่า KVM จะทำงานได้โดยไม่มีปัญหา

หากคุณได้รับข้อความต่อไปนี้ที่ทางออก:

CPU ของคุณไม่รองรับส่วนขยาย KVM การเร่งความเร็ว KVM ไม่สามารถใช้งานได้

คุณยังคงสามารถใช้เครื่องเสมือนได้ แต่จะช้ากว่ามาก

ติดตั้งระบบ 64 บิตในฐานะแขก

จัดสรร RAM มากกว่า 2 GB ให้กับระบบของแขก

การติดตั้ง

Sudo apt-get ติดตั้ง qemu-kvm libvirt-bin ubuntu-vm-builder สะพาน-utils

นี่คือการติดตั้งบนเซิร์ฟเวอร์ที่ไม่มี X กล่าวคือ ไม่มีอินเทอร์เฟซแบบกราฟิก คุณสามารถติดตั้งได้ด้วยคำสั่ง

Sudo apt-get ติดตั้ง virt-manager

หลังจากนี้รายการ "Virtual Machine Manager" จะปรากฏในเมนูและทุกอย่างจะทำงานได้ด้วยความน่าจะเป็นระดับสูง หากยังคงเกิดปัญหาใดๆ คุณจะต้องอ่านคำแนะนำในวิกิภาษาอังกฤษ

การสร้างระบบแขก

ขั้นตอนการสร้างระบบเกสต์โดยใช้ GUI นั้นค่อนข้างง่าย

แต่สามารถอธิบายโหมดข้อความได้

qcow2

เมื่อสร้างระบบโดยใช้อินเทอร์เฟซแบบกราฟิกเป็นฮาร์ดไดรฟ์ คุณจะได้รับแจ้งให้เลือกไฟล์รูปภาพหรืออุปกรณ์บล็อกที่มีอยู่ หรือสร้างไฟล์ใหม่ด้วยข้อมูลดิบ (RAW) อย่างไรก็ตาม นี่ยังห่างไกลจากรูปแบบไฟล์เดียวที่มีอยู่ ในบรรดาดิสก์ทุกประเภทที่แสดงอยู่ใน man qemu-img ดิสก์ที่ยืดหยุ่นและทันสมัยที่สุดคือ qcow2 รองรับสแน็ปช็อต การเข้ารหัส และการบีบอัด ต้องสร้างขึ้นก่อนสร้างแขกใหม่

Qemu-img สร้าง -o การจัดสรรล่วงหน้า = ข้อมูลเมตา -f qcow2 qcow2.img 20G

ตามชายคนเดียวกัน qemu-img การจัดสรรข้อมูลเมตาล่วงหน้า (-o preallocation=metadata) ทำให้ดิสก์ใหญ่ขึ้นเล็กน้อยในตอนแรก แต่ให้ประสิทธิภาพที่ดีขึ้นเมื่อรูปภาพจำเป็นต้องขยาย ในกรณีนี้ ตัวเลือกนี้ช่วยให้คุณหลีกเลี่ยงข้อผิดพลาดอันไม่พึงประสงค์ได้ รูปภาพที่สร้างขึ้นเริ่มแรกใช้พื้นที่น้อยกว่าหนึ่งเมกะไบต์และขยายเป็นขนาดที่ระบุตามความจำเป็น ระบบแขกควรเห็นขนาดที่ระบุสุดท้ายนี้ทันที อย่างไรก็ตาม ในระหว่างขั้นตอนการติดตั้ง ระบบอาจเห็นขนาดจริงของไฟล์ โดยปกติแล้วจะปฏิเสธที่จะติดตั้งบนฮาร์ดไดรฟ์ขนาด 200 KB ข้อผิดพลาดไม่เฉพาะเจาะจงกับ Ubuntu อย่างน้อยก็ปรากฏใน RHEL

นอกจากประเภทของรูปภาพแล้ว คุณสามารถเลือกวิธีการเชื่อมต่อได้ในภายหลัง - IDE, SCSI หรือ Virtio Disk ประสิทธิภาพของระบบย่อยของดิสก์จะขึ้นอยู่กับตัวเลือกนี้ ไม่มีคำตอบที่ถูกต้องแน่นอน คุณต้องเลือกตามงานที่จะกำหนดให้กับระบบแขก หากระบบแขกถูกสร้างขึ้น "เพื่อดู" วิธีการใดๆ ก็ตามจะทำได้ โดยทั่วไป I/O มักเป็นจุดคอขวดของเครื่องเสมือน ดังนั้นเมื่อสร้างระบบที่มีการโหลดสูง ปัญหานี้จะต้องได้รับการปฏิบัติอย่างมีความรับผิดชอบมากที่สุด

KVM หรือ Kernel Virtual Module เป็นโมดูลการจำลองเสมือนสำหรับเคอร์เนล Linux ที่ช่วยให้คุณเปลี่ยนคอมพิวเตอร์ของคุณให้เป็นไฮเปอร์ไวเซอร์สำหรับจัดการเครื่องเสมือน โมดูลนี้ทำงานในระดับเคอร์เนลและรองรับเทคโนโลยีการเร่งความเร็วด้วยฮาร์ดแวร์ เช่น Intel VT และ AMD SVM

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

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

ก่อนที่จะดำเนินการติดตั้ง KVM ต่อไป คุณต้องตรวจสอบว่าโปรเซสเซอร์ของคุณรองรับการเร่งการจำลองเสมือนด้วยฮาร์ดแวร์จาก Intel-VT หรือ AMD-V หรือไม่ เมื่อต้องการทำเช่นนี้ ให้เรียกใช้คำสั่งต่อไปนี้:

egrep -c "(vmx|svm)" /proc/cpuinfo

หากผลลัพธ์ส่งคืน 0 แสดงว่าโปรเซสเซอร์ของคุณไม่รองรับการจำลองเสมือนสำหรับฮาร์ดแวร์ หาก 1 ขึ้นไป คุณสามารถใช้ KVM บนเครื่องของคุณได้

ตอนนี้เราสามารถดำเนินการติดตั้ง KVM ต่อไปได้ โดยสามารถรับชุดโปรแกรมได้โดยตรงจากแหล่งเก็บข้อมูลอย่างเป็นทางการ:

sudo apt ติดตั้ง qemu-kvm libvirt-bin bridge-utils virt-manager cpu-checker

เราไม่เพียงแต่ติดตั้งยูทิลิตี้ kvm เท่านั้น แต่ยังติดตั้งไลบรารี libvirt รวมถึงตัวจัดการเครื่องเสมือนด้วย หลังจากการติดตั้งเสร็จสมบูรณ์ คุณจะต้องเพิ่มผู้ใช้ของคุณในกลุ่ม libvirtd เนื่องจากมีเพียงรูทและผู้ใช้ในกลุ่มนี้เท่านั้นที่สามารถใช้เครื่องเสมือน KVM ได้:

sudo gpasswd - ผู้ใช้ libvirtd

หลังจากรันคำสั่งนี้แล้ว ให้ออกจากระบบและเข้าสู่ระบบอีกครั้ง ต่อไป มาตรวจสอบว่าทุกอย่างถูกต้องหรือไม่ เมื่อต้องการทำเช่นนี้ ให้ใช้คำสั่ง kvm-ok:

ข้อมูล: /dev/kvm มีอยู่
สามารถใช้การเร่งความเร็ว KVM ได้

หากทุกอย่างถูกต้อง คุณจะเห็นข้อความเดียวกัน

การใช้ KVM บน Ubuntu 16.04

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

การตั้งค่าบริดจ์ใน NetworkManager

ซึ่งสามารถทำได้หลายวิธี เช่น คุณสามารถใช้โปรแกรมกำหนดค่าเครือข่าย NetworkManager

คลิกไอคอน NetworkManager ในแผง จากนั้นเลือก เปลี่ยนการเชื่อมต่อจากนั้นคลิกปุ่ม เพิ่ม:

จากนั้นเลือกประเภทการเชื่อมต่อ สะพานและกด สร้าง:

ในหน้าต่างที่เปิดขึ้น ให้คลิกปุ่ม เพิ่ม,เพื่อเชื่อมโยงสะพานของเรากับการเชื่อมต่ออินเทอร์เน็ต:

จากรายการ ให้เลือก อีเทอร์เน็ตและกด สร้าง:

ในหน้าต่างถัดไป ให้เลือกในช่อง อุปกรณ์,อินเทอร์เฟซเครือข่ายที่บริดจ์ของเราควรเชื่อมโยง:

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

การตั้งค่าสะพานด้วยตนเอง

ขั้นแรก คุณต้องติดตั้งชุดยูทิลิตี้ Bridge-utils หากคุณยังไม่ได้ดำเนินการ:

sudo apt ติดตั้ง bridge-utils

จากนั้นใช้โปรแกรม brctl เราสามารถสร้างสะพานที่เราต้องการได้ เมื่อต้องการทำเช่นนี้ ใช้คำสั่งต่อไปนี้:

sudo brctl addbr สะพาน 0
$ sudo ip addr แสดง
$ sudo addif สะพาน 0 eth0

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

ตอนนี้คุณต้องเพิ่มสองสามบรรทัดในการตั้งค่าเครือข่ายเพื่อให้ทุกอย่างเริ่มต้นโดยอัตโนมัติหลังจากที่ระบบเริ่มทำงาน เมื่อต้องการทำเช่นนี้ ให้เปิดไฟล์ /etc/network/interfaces และเพิ่มบรรทัดต่อไปนี้:

sudo gedit /etc/network/interfaces

ย้อนกลับ
สะพานอัตโนมัติ0
iface หรือ inet loopback
iface สะพาน 0 inet dhcp
bridge_ports eth0

เมื่อเพิ่มการตั้งค่าแล้ว ให้รีบูตเครือข่าย:

sudo systemctl รีสตาร์ทเครือข่าย

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

การสร้างเครื่องเสมือน KVM

การตั้งค่า Ubuntu KVM เสร็จสมบูรณ์ และตอนนี้เราสามารถใช้งานต่อไปได้ ขั้นแรก มาดูรายการเครื่องเสมือนที่มีอยู่:

virsh -c qemu:///รายการระบบ

มันว่างเปล่า คุณสามารถสร้างเครื่องเสมือนผ่านเทอร์มินัลหรือในส่วนต่อประสานกราฟิก หากต้องการสร้างผ่านเทอร์มินัล ให้ใช้คำสั่ง virt-install ก่อนอื่นไปที่โฟลเดอร์ libvirt:

ซีดี /var/lib/libvirt/boot/

ในการติดตั้ง CentOS คำสั่งจะมีลักษณะดังนี้:

sudo virt-ติดตั้ง\
--virt-type=kvm \
--ชื่อ centos7\
--แรม 2048\
--vcpus=2 \
--os-variant=rhel7 \
--hvm\
--cdrom=/var/lib/libvirt/boot/CentOS-7-x86_64-DVD-1511.iso \
--network=bridge=br0,model=virtio \
--กราฟิก vnc\
--disk path=/var/lib/libvirt/images/centos7.qcow2,size=40,bus=virtio,format=qcow2

มาดูกันว่าพารามิเตอร์ของคำสั่งนี้หมายถึงอะไร:

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

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

sudo virsh vncdisplay centos7.1

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

ไปที่โฟลเดอร์สำหรับรูปภาพ:

ซีดี /var/lib/libvirt/boot/

คุณสามารถดาวน์โหลดอิมเมจการติดตั้งจากอินเทอร์เน็ตได้หากจำเป็น:

sudo wget https://mirrors.kernel.org/debian-cd/current/amd64/iso-dvd/debian-8.5.0-amd64-DVD-1.iso

จากนั้นมาสร้างเครื่องเสมือน:

sudo virt-ติดตั้ง\
--virt-type=kvm \
--name=เดบิน่า8 \
--แรม=2048\
--vcpus=2 \
--os-variant=debian8 \
--hvm\
--cdrom=/var/lib/libvirt/boot/debian-8.5.0-amd64-DVD-1.iso \
--network=bridge=bridge0,model=virtio \
--กราฟิก vnc\
--disk path=/var/lib/libvirt/images/debian8.qcow2,size=40,bus=virtio,format=qcow2

ตอนนี้เรามาดูรายการเครื่องที่มีอยู่อีกครั้ง:

virsh -c qemu:///รายการระบบ

ในการเริ่มเครื่องเสมือนคุณสามารถใช้คำสั่ง:

sudo virsh เริ่มชื่อเครื่อง

หากต้องการหยุด:

ชื่อเครื่องปิดเครื่อง sudo virsh

หากต้องการเปลี่ยนเป็นโหมดสลีป:

sudo virsh ระงับชื่อเครื่อง

หากต้องการรีบูต:

sudo virsh รีบูตชื่อเครื่อง

sudo virsh รีเซ็ตชื่อเครื่อง

หากต้องการลบเครื่องเสมือนโดยสมบูรณ์:

sudo virsh ทำลายชื่อเครื่อง

การสร้างเครื่องเสมือนใน GUI\

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

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

ในหน้าจอถัดไป ให้เลือกจำนวนหน่วยความจำที่จะใช้ได้กับเครื่องเสมือน รวมถึงจำนวนแกนประมวลผล:

ในหน้าจอนี้ คุณต้องเลือกขนาดของฮาร์ดไดรฟ์ที่จะสามารถใช้ได้ในเครื่องของคุณ:

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

หลังจากนี้เครื่องจะพร้อมใช้งานและจะปรากฏในรายการ คุณสามารถเปิดใช้งานได้โดยใช้สามเหลี่ยมสีเขียวบนแถบเครื่องมือผู้จัดการ

ข้อสรุป

ในบทความนี้ เราดูวิธีการติดตั้ง KVM Ubuntu 16.04 เราดูวิธีเตรียมสภาพแวดล้อมนี้ให้พร้อมสำหรับการทำงานอย่างเต็มที่ รวมถึงวิธีสร้างเครื่องเสมือนและใช้งาน หากคุณมีคำถามใด ๆ ถามในความคิดเห็น!

เพื่อสรุปการบรรยายจาก Yandex เกี่ยวกับการจำลองเสมือนใน Linux: