Ik schrijf dit briefje om dit aan te tonen stapsgewijze installatie en het opzetten van een op KVM gebaseerde virtuele machine in Linux. Ik schreef eerder over virtualisatie, waarbij ik het prachtige .

Nu zit ik met een huurprobleem. goede ober met een grote hoeveelheid RAM en volumineus harde schijf. Maar ik wil projecten niet rechtstreeks op de hostmachine uitvoeren, dus zal ik ze opsplitsen in afzonderlijke kleine virtuele servers met Linux- of Docker-containers (ik zal er in een ander artikel over praten).

Alle moderne cloudhosting werken volgens hetzelfde principe, d.w.z. een hoster op goede hardware levert veel op virtuele servers, dat we vroeger VPS/VDS noemden, en distribueert deze naar gebruikers, of automatiseert dit proces (hallo, DigitalOcean).

KVM (kernelgebaseerde virtuele machine) is software voor Linux, waarbij gebruik wordt gemaakt van x86-compatibele processorhardware om te werken met Intel VT/AMD SVM-virtualisatietechnologie.

KVM installeren

Ik zal alle machinaties uitvoeren van het maken van een virtuele machine op Ubuntu 16.04.1 LTS OS. Om te controleren of uw processen hardwarevirtualisatie ondersteunen Intel-gebaseerd VT/AMD SVM, voer uit:

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

Als de terminal niet leeg is, is alles in orde en kan KVM worden geïnstalleerd. Ubuntu ondersteunt officieel alleen de KVM-hypervisor (meegeleverd met Linux-kernels) en adviseert om de libvirt-bibliotheek te gebruiken als hulpmiddel om deze te beheren, wat we vervolgens zullen doen.

U kunt ook de ondersteuning voor hardwarevirtualisatie in Ubuntu controleren met behulp van de opdracht:

Als het lukt, zie je zoiets als dit:

INFO: /dev/kvm bestaat KVM-versnelling kan worden gebruikt

Installeer pakketten voor het werken met KVM:

Sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils

Als u toegang heeft tot grafische schil systeem, dan kunt u installeren GUI-beheerder libvirt:

Sudo apt-get install virt-manager

Het gebruik van virt-manager is vrij eenvoudig (niet moeilijker dan VirtualBox), dus in dit artikel zullen we het hebben over de console-optie voor het installeren en configureren van een virtuele server.

Een virtuele server installeren en configureren

In de consoleversie van installatie, configuratie en systeembeheer, een onmisbaar hulpmiddel is het virsh-hulpprogramma (een add-on voor de libvirt-bibliotheek). Zij heeft groot aantal opties en parameters, gedetailleerde beschrijving kan als volgt worden verkregen:

Man virsh

of bel de standaard "help":

Virsh hulp

Ik blijf er altijd bij volgende regels bij het werken met virtuele servers:

1. Ik houd iso-afbeeldingen Besturingssysteem in de map /var/lib/libvirt/boot
2. Ik bewaar afbeeldingen virtuele machines in de map /var/lib/libvirt/images
3. Ik wijs elke nieuwe virtuele machine expliciet een eigen statisch IP-adres toe via DHCP-server hypervisor.

Laten we beginnen met het installeren van de eerste virtuele machine (64-bit server Ubuntu 16.04 LTS):

Cd /var/lib/libvirt/boot sudo wget http://releases.ubuntu.com/16.04/ubuntu-16.04.1-desktop-amd64.iso

Na het downloaden van de image start u de installatie:

Sudo virt-install \ --virt-type=kvm \ --name ubuntu1604\ --ram 1024 \ --vcpus=1 \ --os-variant=ubuntu16.04 \ --hvm \ --cdrom=/var/ lib/libvirt/boot/ubuntu-16.04.1-server-amd64.iso \ --network netwerk=default,model=virtio \ --graphics vnc \ --schijfpad=/var/lib/libvirt/images/ubuntu1604. img,size=20,bus=virtio

Al deze parameters vertalen naar " menselijke taal", het blijkt dat we een virtuele machine maken met Ubuntu 16.04 OS, 1024 MB RAM, 1 processor, een standaard netwerkkaart (de virtuele machine heeft toegang tot internet alsof het NAT is), 20 GB HDD.

Het is de moeite waard om op de parameter te letten --os-variant, vertelt het de hypervisor aan welk besturingssysteem de instellingen moeten worden aangepast.
Lijst beschikbare opties Het besturingssysteem kan worden verkregen door de opdracht uit te voeren:

Osinfo-query os

Als een dergelijk hulpprogramma niet op uw systeem aanwezig is, installeer dan:

Sudo apt-get install libosinfo-bin

Na het starten van de installatie verschijnt het volgende bericht in de console:

Domeininstallatie wordt nog uitgevoerd. Dat kan maak opnieuw verbinding met de console om het installatieproces te voltooien.

Dit is een normale situatie, wij zullen de installatie via VNC voortzetten.
Laten we eens kijken naar welke poort het is aangemaakt op onze virtuele machine (bijvoorbeeld in de volgende terminal):

Virsh dumpxml ubuntu1604... ...

Poort 5900, op lokaal adres 127.0.0.1. Om verbinding te maken met VNC moet u Port Forwarding via ssh gebruiken. Voordat u dit doet, moet u ervoor zorgen dat TCP-forwarding is ingeschakeld in de ssh-daemon. Om dit te doen, ga naar de sshd-instellingen:

Kat /etc/ssh/sshd_config | grep AllowTcpForwarding

Als er niets is gevonden of als u het volgende ziet:

AllowTcpForwarding-nr

Vervolgens bewerken we de configuratie naar

ToestaanTcpForwarding ja

en start sshd opnieuw op.

Port forwarding instellen

We voeren de opdracht uit op de lokale machine:

Ssh -fN -l inloggen -L 127.0.0.1:5900:localhost:5900 server_ip

Hier hebben we ssh geconfigureerd port forwarding van lokale poort 5900 naar serverpoort 5900. Nu kunt u verbinding maken met VNC via elke VNC-client. Ik geef de voorkeur aan UltraVNC vanwege zijn eenvoud en gemak.

Na een succesvolle verbinding wordt het scherm weergegeven standaard raam groeten voor het starten van de Ubuntu-installatie:

Nadat de installatie is voltooid en de gebruikelijke herstart is voltooid, verschijnt het inlogvenster. Na het inloggen bepalen we het IP-adres van de nieuw aangemaakte virtuele machine om deze later statisch te maken:

Ifconfig

We herinneren het ons en gaan naar de hostmachine. We halen het mac-adres van de “netwerkkaart” van de virtuele machine eruit:

Virsh dumpxml ubuntu1604 | grep " mac-adres"

Laten we ons mac-adres onthouden:

De netwerkinstellingen van de hypervisor bewerken:

Sudo virsh net-edit standaard

We zoeken naar DHCP en voegen dit toe:

Het zou er ongeveer zo uit moeten zien:

Om de instellingen van kracht te laten worden, moet u de DHCP-server van de hypervisor opnieuw opstarten:

Sudo virsh net-destroy standaard sudo virsh net-start standaard sudo service libvirt-bin opnieuw opstarten

Hierna starten we de virtuele machine opnieuw op, nu zal er altijd het IP-adres aan toegewezen zijn: 192.168.122.131.

Er zijn andere manieren om een ​​statisch IP-adres voor een virtuele machine in te stellen, bijvoorbeeld door de netwerkinstellingen rechtstreeks in het gastsysteem te bewerken, maar hier is het wat je hartje begeert. Ik heb zojuist de optie laten zien die ik het liefst gebruik.

Voer het volgende uit om verbinding te maken met de terminal van de virtuele machine:

Ssh 192.168.122.131

De auto is klaar voor de strijd.

Virsh: commandolijst

Om te zien rennen virtuele gastheren(alle beschikbare kunnen worden verkregen door --all toe te voegen):

Sudo virsh-lijst

U kunt de host opnieuw opstarten:

Sudo virsh start $VM_NAME opnieuw op

Een virtuele machine stoppen:

Sudo virsh stop $VM_NAME

Stop uitvoeren:

Sudo virsh vernietig $VM_NAME

Sudo virsh start $VM_NAME

Uitzetten:

Sudo virsh sluit $VM_NAME af

Toevoegen aan autorun:

Sudo virsh autostart $VM_NAME

Heel vaak is het nodig om een ​​systeem te klonen om het in de toekomst als raamwerk voor andere virtuele besturingssystemen te kunnen gebruiken. Hiervoor wordt het hulpprogramma virt-clone gebruikt.

Virt-kloon --help

Het kloont een bestaande virtuele machine en verandert hostgevoelige gegevens, bijvoorbeeld het Mac-adres. Wachtwoorden, bestanden en andere gebruikersspecifieke informatie in de kloon blijven hetzelfde. Als het IP-adres op de gekloonde virtuele machine handmatig is geregistreerd, kunnen er problemen optreden met SSH-toegang tot de kloon als gevolg van een conflict (2 hosts met hetzelfde IP-adres).

Naast het installeren van een virtuele machine via VNC, is het ook mogelijk om X11Forwarding te gebruiken via het virt-manager hulpprogramma. Op Windows kun je hiervoor bijvoorbeeld Xming en PuTTY gebruiken.

Als Linux-liefhebber controleer ik veel Open bron en Linux-applicaties, evenals distributies elke dag. In principe gebruik ik Oracle VirtualBox voor het testen en reproduceren van verschillende besturingssystemen. VirtualBox is een populaire virtualisatietool voor het implementeren of testen van verschillende soorten distributies. Net als Oracle VirtualBox zijn er veel virtualisatieproducten zoals OpenVZ, KVM, Proxmox, enz. Vandaag bespreken we QEMU.

QEMU is een emulator en machinevirtualizer die wordt geleverd met open broncode, waarmee gebruikers bestanden kunnen maken en beheren virtuele machines binnen besturingssysteem.

Bij gebruik als machine QEMU-emulator kunt besturingssystemen en programma's die voor de ene machine zijn gemaakt, op een andere machine uitvoeren (bijvoorbeeld uw eigen pc). Door dynamische vertaling te gebruiken, worden zeer goede prestaties behaald.

Bij gebruik als virtualizer bereikt QEMU zeer vergelijkbare prestaties door gastcode rechtstreeks op de hostprocessor uit te voeren. QEMU ondersteunt virtualisatie bij gebruik onder de Xen-hypervisor of met met behulp van KVM Linux-kernelmodule.

QEMU heeft twee bedrijfsmodi:

Volledige systeememulatie: in deze modus emuleert QEMU een volwaardig systeem(zoals een pc), inclusief de processor en diverse randapparatuur. Het kan worden gebruikt om verschillende besturingssystemen uit te voeren zonder dat u de pc opnieuw hoeft op te starten of systeemcode te debuggen.
Emulatie in gebruikersmodus: In deze modus kan QEMU worden uitgevoerd Linux-processen, samengesteld voor de ene processor op een andere processor. Het kan bijvoorbeeld worden gebruikt om wijn uit te voeren of om kruiscompilatie en kruisfoutopsporing te vergemakkelijken.

QEMU kan draaien zonder een kernelhoststuurprogramma en toch acceptabele prestaties leveren.

Installeer QEMU op Ubuntu 16.04

Laten we in dit voorbeeld kijken hoe we QEMU op Ubuntu 16.04 LTS kunnen installeren en configureren, en hoe we virtuele machines kunnen maken en beheren.

QEMU is standaard beschikbaar in de Ubuntu-repository's. We kunnen het dus installeren met de Virt Manager-tool, met behulp van de opdracht:

Sudo apt-installatie qemu-kvm qemu qemu-systeem virt-manager virt-viewer libvirt-bin

Nadat u de bovenstaande pakketten hebt geïnstalleerd, start u het systeem opnieuw op.

Virtuele machines maken

Laten we nu een nieuwe virtuele machine maken.

Eerst moet je creëren virtueel beeld harde schijf voor de nieuwe virtuele machine. Laten we bijvoorbeeld creëren beeld van een stoere schijfgrootte 20 GB.

Qemu-img maak ubuntu.img 20G

Download dan installatie afbeelding Ubuntu-servers 15.04 vanaf de officiële website.

Voer de volgende opdracht uit om de virtuele machine op te starten:

Voor 64bit-systemen

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

Voor 32bit-systemen

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

Waar “/home/linuxthebest/Downloads/ubuntu-15.04-server-i386.iso” de map is waar de afbeelding is gedownload, en 1024 de grootte is van het toegewezen RAM voor de machine.

Tijdens het opstarten verschijnt het installatiescherm, druk op Enter en ga verder met de installatie zoals gewoonlijk.

Nadat de installatie is voltooid, kan het systeem worden opgestart met behulp van de opdracht:

Qemu -hda ubuntu.img -m 1024

Dat is het.

Vind je de opdrachtregel niet leuk? Het maken en beheren van virtuele machines vanaf de opdrachtregel kan voor sommige gebruikers een beetje lastig zijn. Maak je geen zorgen, we kunnen ook virtuele machines maken met behulp van een GUI-tool genaamd Virtuele machinebeheerder (Virt Manager).

Als u het nog niet eerder hebt geïnstalleerd, kunt u het installeren met behulp van de opdracht

Sudo apt installeer virt-manager qemu-system libvirt-bin

Creëer en beheer virtuele machines met behulp van Virt Manager

Start Virtual Machine Manager

Sudo virt-manager

Standaard ziet de Virt Manager-interface er als volgt uit.

Nu gaan we Ubuntu 16.10 maken en installeren op een virtuele machine.

Om een ​​virtuele machine te maken, ga naar Bestand -> Nieuwe virtuele machine.

Selecteer welk besturingssysteem u wilt installeren.

U kunt het gastbesturingssysteem installeren met behulp van een lokale ISO/CD-ROM-image, Netwerk installatie, server PXE, of importeer bestaande schijfimages. Bovendien kunt u de gast-OS-architectuur selecteren aanvullende parameters.

Selecteer de hoeveelheid RAM en processors.

Voer uw maat in virtueel moeilijk schijf. Standaard is 8 GB.

Voer de naam van uw gastbesturingssysteem in. En selecteer het netwerktype uit de geavanceerde opties. Klik ten slotte op Voltooien.

Nadat u op de knop Voltooien hebt geklikt, wordt het gastbesturingssysteem automatisch geladen.

Dat is het. Installeer nu het gastbesturingssysteem zoals u dat op een gewoon systeem zou doen.

Ik heb Ubuntu 16.10 geïnstalleerd in virt manager, en trouwens, unity 8 draait daar, vergeleken met virtualbox, waarin het niet werkt, dus als je een nieuwe werkomgeving wilt testen, kun je virt manager installeren en unity 8 daar draaien .

In dit inleidende artikel zal ik kort over alles praten software, gebruikt in het serviceontwikkelingsproces. Ze zullen in de volgende artikelen in meer detail worden besproken.

Waarom ? Dit besturingssysteem is voor mij dichtbij en begrijpelijk, dus er was geen kwelling, kwelling of gooien bij het kiezen van een distributie. Speciale voordelen ten opzichte van Red Hat Enterprise-Linux Dat doet hij niet, maar er is voor gekozen om met een bekend systeem te werken.

Als u van plan bent uw eigen infrastructuur met vergelijkbare technologieën in te zetten, raad ik u aan voor RHEL te kiezen: dankzij goede documentatie en goed geschreven applicatieprogramma's dit zal, zo niet een orde van grootte, dan zeker twee keer zo eenvoudig zijn, en dankzij het ontwikkelde certificeringssysteem zal het zonder veel moeite mogelijk zijn om een ​​aantal specialisten te vinden die op het juiste niveau bekend zijn met dit besturingssysteem.

We hebben opnieuw besloten om te gebruiken Debian Knijp met een set pakketten van Sid/Experimenteel en sommige pakketten zijn gebackporteerd en gecompileerd met onze patches.
Er zijn plannen om een ​​repository met pakketten te publiceren.

Bij het kiezen van virtualisatietechnologie werden twee opties overwogen: Xen en KVM.

Er werd ook rekening gehouden met het feit dat er een groot aantal ontwikkelaars, hosters en commerciële oplossingen op basis van Xen waren - hoe interessanter het was om een ​​oplossing op basis van KVM te implementeren.

De belangrijkste reden waarom we besloten om KVM te gebruiken is de noodzaak om virtuele machines te draaien met FreeBSD en, in de toekomst, MS Windows.

Om virtuele machines te beheren, bleek het uiterst handig om producten te gebruiken die de API gebruiken: virsh, virt-manager, virt-install, pr.

Dit is een systeem dat de instellingen van virtuele machines opslaat, beheert, er statistieken over bijhoudt, ervoor zorgt dat de interface van de virtuele machine wordt verhoogd bij het opstarten, apparaten met de machine verbindt - over het algemeen doet het een heleboel dingen nuttig werk en daarbovenop nog een beetje.

Natuurlijk is de oplossing niet ideaal. De nadelen zijn onder meer:

• Absoluut waanzinnige foutmeldingen.
• Onvermogen om een ​​deel van de configuratie van de virtuele machine direct te wijzigen, hoewel QMP (QEMU Monitor Protocol) dit toestaat.
• Soms is het om een ​​onbekende reden onmogelijk om verbinding te maken met libvirtd - het reageert niet meer op externe gebeurtenissen.

Het grootste probleem bij het implementeren van de service was vanaf het begin de beperking van de bronnen voor virtuele machines. In Xen werd dit probleem opgelost met behulp van een interne planner die bronnen tussen virtuele machines verdeelt - en het beste van alles: de mogelijkheid om schijfbewerkingen inbegrepen.

Er was niets vergelijkbaars in KVM tot de komst van het mechanisme voor toewijzing van kernelbronnen. Zoals gebruikelijk in Linux werd de toegang tot deze functies geïmplementeerd via een special bestandssysteem cgroep, waarin, met behulp van gewoon systeemoproepen write(), zou je een proces aan de groep kunnen toevoegen, het zijn gewicht in papegaaien kunnen toewijzen, de kern kunnen specificeren waarop het zal draaien, specificeren doorvoer schijf die dit proces kan gebruiken, of, nogmaals, er een gewicht aan toekennen.

Het voordeel is dat dit allemaal binnen de kernel wordt geïmplementeerd, en dat het niet alleen voor de server kan worden gebruikt, maar ook voor de desktop (die werd gebruikt in de beroemde “The ~200 Line Linux Kernel Patch That Does Wonders”). En naar mijn mening is dit een van de belangrijkste veranderingen in de 2.6-branch, afgezien van mijn favoriet #12309, en niet het archiveren van een ander bestandssysteem. Nou ja, behalve misschien voor POHMELFS (maar puur vanwege de naam).

Mijn houding ten opzichte van deze nutsbibliotheek is zeer dubbelzinnig.

Enerzijds ziet het er ongeveer zo uit:

En dit ding is ook verdomd moeilijk om vanaf de broncode te bouwen, laat staan ​​in een pakket: soms lijkt het mij dat Linux From Scratch een beetje gemakkelijker is om vanaf het begin te bouwen.

Aan de andere kant is het een zeer krachtig iets waarmee je afbeeldingen voor virtuele machines kunt maken, deze kunt wijzigen, comprimeren, grub kunt installeren, de partitietabel kunt wijzigen, configuratiebestanden, breng "ijzeren" machines over naar virtuele omgeving, breng virtuele machines over van de ene afbeelding naar de andere, breng virtuele machines over van een afbeelding naar hardware en eerlijk gezegd laat mijn fantasie me hier een beetje in de steek. Oh ja: je kunt ook een daemon in een virtuele Linux-machine draaien en live toegang krijgen tot de gegevens van de virtuele machine, en dit allemaal in shell, python, perl, java, ocaml. Dit is kort en verre van volledige lijst van wat er mee gedaan kan worden.

Interessant is dat het grootste deel van de code wordt gegenereerd op het moment van assemblage, evenals de documentatie voor het project. Ocaml en perl worden veel gebruikt. De code zelf is geschreven in C, die vervolgens wordt verpakt in OCaml, en de herhaalde stukjes code worden zelf gegenereerd. Het werken met afbeeldingen gebeurt door een speciale service-image (supermin-apparaat) te lanceren, waarnaar opdrachten via een kanaal ernaar worden verzonden. Deze reddingsimage bevat een bepaalde reeks hulpprogramma's, zoals parted, mkfs en andere die nuttig zijn voor een systeembeheerder.

Onlangs begon ik het zelfs thuis te gebruiken, toen ik de gegevens die ik nodig had uit de nandroid-afbeelding haalde. Maar dit vereist een kernel die yaffs ondersteunt.

Ander

Hieronder staan ​​er nog een paar interessante links voor een beschrijving van de gebruikte software - lees en bestudeer deze zelf, indien geïnteresseerd. Bijvoorbeeld,

In Ubuntu wordt het aanbevolen om de KVM-hypervisor (virtuele machinebeheerder) en de libvirt-bibliotheek als beheertools hiervoor te gebruiken. Libvirt bevat een set software-API's en aangepaste toepassingen beheer van virtuele machines (VM's) virt-manager (grafische interface, GUI) of virsh (opdrachtregel, CLI). Als alternatieve beheerders u kunt convirt (GUI) of convirt2 (WEB-interface) gebruiken.

Momenteel wordt alleen de KVM-hypervisor officieel ondersteund op Ubuntu. Deze hypervisor maakt deel uit van de kernelcode van het Linux-besturingssysteem. In tegenstelling tot Xen ondersteunt KVM geen paravirtualisatie, wat betekent dat om het te kunnen gebruiken, uw CPU VT-technologieën moet ondersteunen. U kunt controleren of uw processor deze technologie ondersteunt door de opdracht in de terminal uit te voeren:

Als u hierdoor het volgende bericht ontvangt:

INFO: /dev/kvm bestaat KVM-versnelling kan worden gebruikt

Dit betekent dat KVM zonder problemen zal werken.

Als u bij de uitgang het volgende bericht heeft ontvangen:

Uw CPU ondersteunt geen KVM-extensies KVM-versnelling kan NIET worden gebruikt

dan kun je nog steeds de virtuele machine gebruiken, maar het zal veel langzamer zijn.

Installeer 64-bits systemen als gasten

Wijs meer dan 2 GB RAM toe aan gastsystemen

Installatie

Sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils

Dit is een installatie op een server zonder X, d.w.z. er is geen grafische interface aanwezig. Je kunt het installeren met het commando

Sudo apt-get install virt-manager

Hierna verschijnt het item "Virtual Machine Manager" in het menu en met grote waarschijnlijkheid zal alles werken. Als er zich nog steeds problemen voordoen, moet u de instructies in de Engelse wiki lezen.

Een gastsysteem maken

Procedure voor het aanmaken van een gast met behulp van GUI vrij eenvoudig.

Maar de tekstmodus kan worden beschreven.

qkoe2

Wanneer u een systeem maakt dat de grafische interface als harde schijf gebruikt, wordt u gevraagd een bestaand imagebestand of blokapparaat te selecteren, of een nieuw bestand met ruwe (RAW) data. Dit is echter verre van het enige beschikbare bestandsformaat. Van alle schijftypen die in man qemu-img worden vermeld, is qcow2 de meest flexibele en moderne. Het ondersteunt snapshots, encryptie en compressie. Het moet worden aangemaakt voordat een nieuwe gast wordt aangemaakt.

Qemu-img create -o preallocation=metadata -f qcow2 qcow2.img 20G

Volgens dezelfde man qemu-img maakt het vooraf toewijzen van metadata (-o preallocation=metadata) de schijf in eerste instantie iets groter, maar levert betere prestaties wanneer het beeld moet groeien. Sterker nog, binnen in dit geval Met deze optie kunt u een onaangename bug vermijden. Beeld gemaakt neemt aanvankelijk minder dan een megabyte aan ruimte in beslag en groeit indien nodig naar de opgegeven grootte. Het gastsysteem zou deze finale onmiddellijk moeten zien gespecificeerde maat Tijdens de installatiefase kan ze echter wel zien werkelijke grootte bestand. Uiteraard op installeren harde schijf 200 kB groot zal het weigeren. De bug is niet specifiek voor Ubuntu; hij verschijnt tenminste in RHEL.

Naast het type afbeelding kunt u vervolgens de verbindingsmethode kiezen: IDE, SCSI of Virtio Disk. De prestaties zullen afhangen van deze keuze schijf subsysteem. Er is geen definitief juist antwoord; u moet kiezen op basis van de taak die aan het gastsysteem wordt toegewezen. Als het gastsysteem is gemaakt ‘om naar te kijken’, dan is elke methode voldoende. Over het algemeen is I/O meestal het knelpunt van een virtuele machine, dus bij het creëren van een zwaarbelast systeem moet dit probleem zo verantwoordelijk mogelijk worden behandeld.

Persoonlijk is het voor mij het gemakkelijkst om KVM (Kernel-gebaseerde virtuele machine) te beschouwen als een abstractieniveau bovenën Intel VT-x en AMD-V. We nemen een machine met een processor die een van deze technologieën ondersteunt, en wedden hierop Linux-machine, in Linux installeren we KVM, waardoor we de mogelijkheid krijgen om virtuele machines te maken. Dit is ongeveer hoe cloudhosting werkt, bijvoorbeeld Amazon Web Services. Samen met KVM wordt soms ook Xen gebruikt, maar een bespreking van deze technologie valt buiten het bestek van dit bericht. In tegenstelling toteën, bijvoorbeeld Docker, kunt u met KVM elk besturingssysteem als gastsysteem uitvoeren, maar het heeft ook O Hogere overhead voor virtualisatie.

Opmerking: De hieronder beschreven stappen zijn door mij getest op Ubuntu Linux 14.04, maar in theorie zullen ze grotendeels geldig zijn voor zowel andere versies van Ubuntu als andere Linux-distributies. Alles zou zowel op de desktop als op de server moeten werken, toegankelijk via SSH.

KVM installeren

We controleren of Intel VT-x of AMD-V wordt ondersteund door onze processor:

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

Als iets heet wordt, betekent dit dat het wordt ondersteund en dat je verder kunt.

KVM installeren:

sudo apt-get-update
sudo apt-get install qemu-kvm libvirt-bin virtinst bridge-utils

Wat wordt meestal opgeslagen waar:

• /var/lib/libvirt/boot/ - ISO-images voor het installeren van gastsystemen;
• /var/lib/libvirt/images/ - afbeeldingen harde schijven gastsystemen;
• /var/log/libvirt/ - hier zou je naar alle logs moeten zoeken;
• /etc/libvirt/ - map met configuratiebestanden;

Nu KVM is geïnstalleerd, gaan we onze eerste virtuele machine maken.

Het creëren van de eerste virtuele machine

Ik heb FreeBSD als gastsysteem gekozen. Download de ISO-image van het systeem:

cd /var/lib/libvirt/boot/
sudo wget http://ftp.freebsd.org/ pad/ naar/some-freebsd-disk.iso

Virtuele machines worden in de meeste gevallen beheerd met behulp van het virsh hulpprogramma:

sudo virsh --help

Voordat we de virtuele machine starten, moeten we wat aanvullende informatie verzamelen.

We kijken naar de lijst met beschikbare netwerken:

sudo virsh net-lijst

Informatie over een specifiek netwerk bekijken (standaard genoemd):

sudo virsh net-info standaard

Laten we eens kijken naar de lijst met beschikbare optimalisaties voor gastbesturingssystemen:

sudo virt-install --os-variantlijst

Dus nu maken we een virtuele machine met 1 CPU, 1 GB RAM en 32 GB schijfruimte, verbonden met het standaardnetwerk:

sudo virt-install\
--virt-type =kvm\
--naam freebsd10\
--ram 1024\
--vcpus=1\
--os-variant =freebsd8 \
--hvm\
--cdrom =/ var/ lib/ libvirt/ boot/ FreeBSD-10.2 -RELEASE-amd64-disc1.iso \
--netwerk netwerk =standaard,model =virtio \
--grafische vnc\
--schijfpad =/ var/ lib/ libvirt/ images/ freebsd10.img,size =32,bus =virtio

Je kunt zien:

WAARSCHUWING Kan geen verbinding maken met de grafische console: virt-viewer niet
geïnstalleerd. Installeer alstublieft het "virt-viewer" pakket.

Domeininstallatie wordt nog uitgevoerd. U kunt opnieuw verbinding maken met de console
om het installatieproces te voltooien.

Dit is normaal, dit is hoe het zou moeten zijn.

Bekijk vervolgens de eigenschappen van de virtuele machine in XML-formaat:

sudo virsh dumpxml freebsd10

Hier zijn de meeste volledige informatie. Daartoe behoort bijvoorbeeld een MAC-adres, dat we later nodig zullen hebben. Voorlopig zoeken we informatie over VNC. In mijn geval:

Met uw favoriete client (ik gebruik persoonlijk Rammina) loggen we in via VNC, indien nodig met behulp van SSH port forwarding. We komen meteen in het FreeBSD-installatieprogramma. Dan is alles zoals gewoonlijk: Volgende, Volgende, Volgende, we krijgen het geïnstalleerde systeem.

Basiscommando's

Laten we nu kijken naar de basisopdrachten voor het werken met KVM.

Een lijst krijgen van alle virtuele machines:

sudo virsh lijst --all

Informatie verkrijgen over een specifieke virtuele machine:

sudo virsh dominfo freebsd10

Virtuele machine starten:

sudo virsh start freebsd10

Virtuele machine stoppen:

sudo virsh shutdown freebsd10

Nauwelijks de virtuele machine te pakken (ondanks de naam, this Niet verwijdering):

sudo virsh vernietig freebsd10

Start de virtuele machine opnieuw op:

sudo virsh start freebsd10 opnieuw op

Virtuele machine klonen:

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

Autorun in-/uitschakelen:

sudo virsh autostart freebsd10
sudo virsh autostart -- schakel freebsd10 uit

Virsh uitvoeren in dialoogmodus (alle commando's in dialoogmodus - zoals hierboven beschreven):

sudo virsh

De eigenschappen van de virtuele machine in XML bewerken, inclusief hier kunt u de limiet op de hoeveelheid geheugen wijzigen, enz.:

sudo virsh bewerk freebsd10

Belangrijk! Opmerkingen uit de bewerkte XML zijn helaas verwijderd.

Wanneer de virtuele machine wordt gestopt, kan de grootte van de schijf ook worden gewijzigd:

sudo qemu-img resize /var/ lib/ libvirt/ images/ freebsd10.img -2G
sudo qemu-img info /var/lib/libvirt/images/freebsd10.img

Belangrijk! Uw gastbesturingssysteem zal het waarschijnlijk niet leuk vinden dat de schijf plotseling groter of kleiner wordt. IN beste scenario, zal het opstarten in de noodmodus met een voorstel om de schijf opnieuw te partitioneren. Waarschijnlijk zou je dat niet willen doen. Het kan veel eenvoudiger zijn om een ​​nieuwe virtuele machine te maken en alle gegevens ernaar te migreren.

Back-up en herstel zijn vrij eenvoudig. Het is voldoende om de dumpxml-uitvoer ergens op te slaan, evenals de schijfkopie, en deze vervolgens te herstellen. Op YouTube heb het filmpje kunnen vinden Met een demonstratie van dit proces is alles echt niet moeilijk.

Netwerkinstellingen

Een interessante vraag: hoe bepaal je welk IP-adres de virtuele machine heeft ontvangen na het laden? KVM doet dit op een slimme manier. Uiteindelijk heb ik dit script in Python geschreven:

#!/usr/bin/env python3

# virt-ip.py-script
# (c) 2016 Aleksander Alekseev
# http://site/

importsysteem
import re
importeer os
subproces importeren
vanuit xml .etree importeer ElementTree

def eprint(str) :
print(str, bestand = sys.stderr)

if len(sys.argv)< 2 :
eprint("GEBRUIK: " + sys.argv [ 0 ] + " " )
eprint("Voorbeeld: " + sys .argv [ 0 ] + "freebsd10" )
sys.exit(1)

als os .geteuid() != 0 :
eprint("ERROR: je moet root zijn" )
eprint("Hint: voer `sudo " + sys .argv [ 0 ] + " ...`" ) uit;
sys.exit(1)

if subproces .call ( "welke arping 2>&1 >/dev/null", shell = Waar ) != 0 :
eprint("FOUT: arping niet gevonden" )
eprint( "Hint: voer `sudo apt-get install arping` uit")
sys.exit(1)

Domein = sys.argv[1]

indien niet opnieuw .match ("^*$", domein):
eprint( "ERROR: ongeldige tekens in domeinnaam")
sys.exit(1)

Domout = subproces .check_output ("virsh dumpxml " +domain+" || true" ,
schil = Waar)
domout = domout.decode("utf-8").strip()

als domout == "" :
# foutmelding al afgedrukt door dumpxml
sys.exit(1)

Doc = ElementTree.fromstring(domout)

# 1. maak een lijst van alle netwerkinterfaces
# 2. voer `arping` parallel uit op elke interface
#3.grep antwoordt
cmd = "(ifconfig | knippen -d " " -f 1 | grep -E "." | " + \
"xargs -P0 -I IFACE arping -i IFACE -c 1 () 2>&1 | " + \
"grep "bytes van") || waar"

voor kind in doc.iter() :
if child.tag == "mac" :
macaddr = kind.attrib["adres"]
macout = subproces .check_output (cmd .format (macaddr),
schil = Waar)
print(macout.decode("utf-8"))

Het script werkt met zowel het standaardnetwerk als het overbrugde netwerk, waarvan we de configuratie later zullen bespreken. In de praktijk is het echter veel handiger om KVM zo te configureren dat het altijd dezelfde IP-adressen aan gastsystemen toewijst. Bewerk hiervoor de netwerkinstellingen:

sudo virsh net-edit standaard

... zoiets als dit:

>



>

Nadat u deze wijzigingen heeft aangebracht


>

... en vervang het door iets als:

>

We starten het gastsysteem opnieuw op en controleren of het via DHCP een IP-adres heeft ontvangen van de router. Als u wilt dat het gastsysteem dat heeft statisch IP-adres, wordt dit zoals gebruikelijk geconfigureerd binnen het gastsysteem zelf.

virt-manager programma

Mogelijk ben je ook geïnteresseerd in het virt-manager programma:

sudo apt-get install virt-manager
sudo usermod -a -G libvirtd GEBRUIKERSNAAM

Zo ziet het hoofdvenster eruit:

Zoals je kunt zien is virt-manager niet alleen een GUI voor virtuele machines die lokaal draaien. Met zijn hulp kunt u virtuele machines beheren die op andere hosts draaien, en in realtime prachtige graphics bekijken. Persoonlijk vind ik het vooral handig in virt-manager dat je niet door de configuraties hoeft te zoeken om erachter te komen welke poort VNC op een specifiek gastsysteem draait. U hoeft alleen maar de virtuele machine in de lijst te vinden, te dubbelklikken en toegang te krijgen tot de monitor.

Met de hulp van virt-manager is het ook erg handig om dingen te doen die anders arbeidsintensieve bewerking van XML-bestanden zouden vereisen en, in sommige gevallen, uitvoering extra opdrachten. Bijvoorbeeld het hernoemen van virtuele machines, het instellen van CPU-affiniteit en soortgelijke zaken. Trouwens, CPU-gebruik affiniteit vermindert aanzienlijk het effect van luidruchtige buren en de impact van virtuele machines op het hostsysteem. Gebruik het altijd waar mogelijk.

Als u besluit KVM te gebruiken als vervanging voor VirtualBox, houd er dan rekening mee dat ze geen hardwarevirtualisatie onderling kunnen delen. Om KVM op uw bureaublad te laten werken, moet u niet alleen alle virtuele machines in VirtualBox en Vagrant stoppen, maar ook het systeem opnieuw opstarten. Persoonlijk vind ik KVM veel handiger dan VirtualBox, tenminste omdat je er geen commando voor hoeft uit te voeren sudo /sbin/rcvboxdrv installatie na elke kernelupdate werkt het adequaat met Unity, en kun je over het algemeen alle vensters verbergen.