În vremurile bune, instalarea unui sistem de operare însemna să strângeți toate componentele hardware, să declanșați noul computer cu un disc de instalare într-o unitate periferică și să dezactivați procesul de instalare. Timpul total scurs ar putea rula oriunde între ore și săptămâni.

În aceste zile îmi pot spune „Nu mi-ar deranja să testez asta pe un server care rulează o anumită versiune de CentOS” și – în funcție de un număr de variabile și presupunând că imaginea originală a fost deja descărcată – pot avea o funcționare completă sistemul virtual gata în 30 de secunde. Rezultatele dvs. exacte pot varia, dar nu cu atât de mult.

Puteți vedea cum funcționează toate acestea în noul meu Curs Pluralsight „Optimizare sistem Linux” – pe care se bazează acest articol.

Ce a determinat această schimbare? Virtualizare. Și, în special, virtualizarea containerelor.

Un sistem de operare virtualizat este un sistem de fișiere care conține toate bibliotecile software, binare și fișiere de configurare de care aveți nevoie pentru a lansa o mașină tradițională. Doar că acest sistem de fișiere nu este stocat în partiția rădăcină sau de pornire pe care computerul dvs. ar citi-o pe măsură ce se aprinde, ci în altă parte a volumului de stocare.

Și „pornirea” computerului virtual se întâmplă atunci când unele programe înșelă în mod inteligent fișierele, crezând că rulează singuri pe propriul hardware, atunci când partajează cu adevărat spațiu și resurse cu sistemul de operare gazdă și, poate, cu alte calculatoare virtuale.

În linii mari, există două tipuri de sisteme software utilizate pentru administrarea virtualizării serverului: hipervizorul și containerul.

Hipervizorii oferă un strat de abstracție care permite VM-urilor invitate să creeze un mediu izolat cu acces la hardware-ul sistemului care emulează un server metalic. Aceasta înseamnă că VM-urile hypervisor pot fi construite din orice sistem de operare compatibil cu hardware-ul dvs. de bază. Dar înseamnă, de asemenea, că vor consuma mai mult spațiu și mai multă memorie și vor calcula resurse.

Virtualizarea containerelor

Containerele, pe de altă parte, împărtășesc nucleul sistemului de operare al computerului gazdă și există în spații securizate și izolate atent, gestionate de instrumente de sistem, cum ar fi grupurile cgroup. Deoarece împărtășesc nucleul, memoria și resursele de sistem consumate de containere pot fi cu adevărat minime, fără absolut nimic irosit. Și, după cum veți vedea, viteza pe care o veți rula cu aplicațiile pentru containere va fi uluitoare.

O mulțime de atenție legată de containere în ultimii ani s-a concentrat pe Docker și, mai recent, pe instrumentul de orchestrare a containerelor Google, Kubernetes. De fapt, Kubernetes este foarte potrivit pentru arhitecturi de microservicii la scară de întreprindere.

Dar există o implementare mai veche și, probabil, mai matură a modelului de container care nu a plecat nicăieri. Linux Container Project, LXC, și setul său de instrumente mai recent, LXD, au puncte forte pe care mulți le-ar argumenta, făcându-l un candidat mai bun pentru unele cazuri de utilizare decât Kubernetes. În special, LXC excelează în crearea de medii ușoare și rapide cu nisip pentru testare și dezvoltare de aplicații.

În acest articol, vă voi arăta cum să instalați LXD, cum să pregătiți și să lansați un container simplu care rulează ultra-mic Alpine Linux și apoi cum să deschideți o sesiune de shell în noul dvs. container. De asemenea, voi explica cum să găsiți și să lansați mai multe versiuni ale altor distribuții.

Un lucru pe care ți-l pot spune imediat este că ori de câte ori predau LXC, elevii răspund cu uimire la cât de puternic și eficient poate fi utilizarea containerelor.

Când am terminat cu toate acestea, veți putea declanșa mașini pentru a testa manual orice veți învăța sau lucra în câteva secunde. Atunci când un experiment merge prost, puteți închide și elimina instantaneu un container și construi altul pentru al înlocui. Pur și simplu nu mai există nicio scuză pentru a nu învăța.

Construirea de containere LXD

Vom face ca LXC să funcționeze la o nouă instalare a unei mașini Ubuntu 18.04. În această demonstrație, vom instala și inițializa un mediu LXD și apoi vom folosi versiunea LXD a interfeței liniei de comandă LXC pentru a descărca și lansa un container Alpine Linux. Vom confirma că totul a funcționat și apoi vom arunca o privire în jur pentru a vedea cum este populat mediul.

Voi folosi managerul de pachete snap pentru a instala LXD, deoarece aceasta este acum recomandarea oficială. Și nu doar pentru LXD, atenție: tot felul de aplicații se îndreaptă spre manageri alternativi precum snap sau AppImmage și Flatpak. Încă îmi place aptitudinea mea Debian, dar nu poți lupta cu întreaga lume.

$ sudo snap install lxd

LXD – care, din nou, este un set de instrumente actualizat conceput pentru a gestiona API LXC – vine într-un pachet care include toate dependențele LXC obișnuite. O comandă de instalare și am terminat.

Este important să inițializați mediul LXC folosind comanda lxd init. Puteți configura lucrurile dvs. manual, dar este mai probabil să rezolvați totul în acest fel. Procesul inițial vă va pune o grămadă de întrebări și, cel puțin acum, răspunsurile implicite vor funcționa.

$ sudo lxd init

Odată ce ați terminat, suntem gata să construim primul dvs. container. Indiferent de distribuția și versiunea Linux pe care o dorim, va trebui să găsim și să descărcăm imaginea. Proiectul LXC menține un depozit de o gamă destul de largă de imagini la images.linuxcontainers.org. Puteți vedea că există de obicei mai multe versiuni ale fiecărei distribuții, permițându-vă să creați containere care să funcționeze cu aproape orice software pe care îl puteți arunca.

Voi folosi cea mai recentă versiune a Alpine Linux, deoarece este foarte mică. Simțiți-vă liber să folosiți orice imagine doriți – inclusiv băieții mari, cum ar fi Ubuntu și CentoOS. Desigur, Alpine se va descărca foarte repede.

Dar înainte de a face acest lucru, ar trebui să vă spun cum să aflați sintaxa liniei de comandă necesară pentru a obține imaginea dvs.

După cum puteți vedea în această captură de ecran de pe site-ul web LXD, puteți obține trei informații de care aveți nevoie de pe pagina însăși: numele distro – Alpine, în acest caz – numărul versiunii – 3.10 – și arhitectura . Urmărim amd64.

Cum se utilizeaza containere Linux cu LXC si LXD
Din pagina images.linuxcontainers.org

Acum suntem gata să declanșăm descărcarea executând launch comanda:

$ sudo lxc launch images:alpine/3.10/amd64 demo

Observați cum sintaxa este „lxc”, chiar dacă aceasta este tehnic o interfață LXD. „images” îi spune LXC că imaginea noastră trăiește în repo-ul public pe care l-am văzut mai devreme. Cele trei biți de date – numele distribuției, numărul versiunii și arhitectura sunt introduse separate prin bare oblice. Voi folosi „demo” ca nume al containerului meu. Asta ar trebui să fie tot ce ne trebuie.

Puteți vedea cât de mic este Alpine după cât de repede se descarcă. Conexiunea mea la internet nu este atât de rapidă și nu am jucat niciun joc cu înregistrarea. Pentru a confirma că a funcționat, voi rula „lxc ls” pentru a lista toate containerele instalate în prezent. Există doar una. Iar starea sa actuală este „rulează”.

sudo lxc ls
+------+---------+----------------------+------------+-----------+
| NAME |  STATE  |         IPV4         |    TYPE    | SNAPSHOTS |
+------+---------+----------------------+------------+-----------+
| demo | RUNNING | 10.125.45.119 (eth0) | PERSISTENT | 0         |
+------+---------+----------------------+------------+-----------+

Puteți deschide o sesiune rădăcină care nu se conectează într-un container folosind comanda „lxc exec”. Trebuie doar să specificați numele containerului și apoi spuneți LXC că doriți să rulați un shell folosind interpretorul sh (s-ar putea să preferați /bin/bash dacă lucrați cu un container Ubuntu sau CentOS – apelul dvs. în orice sens). După cum veți putea vedea singur dacă urmăriți acasă, avem un prompt de comandă Linux normal și orice lucru cu Linux-y este acum posibil.

$ sudo lxc exec demo sh
~ # 

De asemenea, puteți rula o singură comandă fără a deschide un shell complet tastând comanda în loc de aceasta sh.

$ sudo lxc exec demo ls /
bin    etc    lib    mnt    proc   run    srv    tmp    var
dev    home   media  opt    root   sbin   sys    usr

Puteți scăpa de coajă oricând doriți să utilizați exit și întoarce-te la gazda ta. Aici, pe lângă listarea containerelor care rulează, pot lista și orice grupuri de stocare. Pool-ul implicit care a fost creat în timpul inițializării este acolo și putem vedea unde este stocată imaginea discului. / var / lib / lxd este, în mod implicit, unde sunt păstrate toate resursele LXC.

$ sudo lxc storage ls
+---------+-------------+--------+--------------------------------+---------+
|  NAME   | DESCRIPTION | DRIVER |             SOURCE             | USED BY |
+---------+-------------+--------+--------------------------------+---------+
| default |             | btrfs  | /var/lib/lxd/disks/default.img | 3       |
+---------+-------------+--------+--------------------------------+---------+

Pot lista în mod similar toate rețelele mele. Se întâmplă să existe câteva punți de rețea pe acest sistem (am jucat puțin, după cum puteți vedea). Există, de asemenea, podul fiz0 enp0s3 folosit de serverul gazdă Ubuntu. Deși între voi și mine, nici ăla nu este fizic, deoarece acesta este de fapt o mașină virtuală care rulează în Oracle’s Virtual Box.

$ lxc network ls
+---------+----------+---------+-------------+---------+
|  NAME   |   TYPE   | MANAGED | DESCRIPTION | USED BY |
+---------+----------+---------+-------------+---------+
| enp0s3  | physical | NO      |             | 1       |
+---------+----------+---------+-------------+---------+
| lxdbr0  | bridge   | YES     |             | 1       |
+---------+----------+---------+-------------+---------+
| mynet   | bridge   | YES     |             | 0       |
+---------+----------+---------+-------------+---------+
| testbr0 | bridge   | YES     |             | 1       |
+---------+----------+---------+-------------+---------+

Dacă ar fi nevoie, am putea adăuga cu ușurință o nouă interfață virtuală în containerul nostru folosind comanda „lxc network attach”. Aici, voi specifica rețeaua fizică și apoi numele containerului nostru.

$ lxc network attach enp0s3 demo

După ce ați terminat, ați putea deschide un nou shell în container pentru a vedea ce s-a schimbat. Acum ar trebui să existe o interfață eth1 listată. Este posibil să fie necesar să reporniți pentru ca toate modificările să aibă efect complet. Făcând acest lucru, vă puteți minuna și cu cât de repede se poate reporni acest lucru – din toate punctele de vedere, se va întâmpla mai repede decât puteți introduce exec comanda pentru a deschide un shell nou.

Bucurați-vă de noul dvs. mediu!

Acest articol se bazează pe conținutul din Curs Pluralsight, „Optimizarea sistemului Linux”. Există mult mai multă bunătate administrativă sub formă de cărți, cursuri și articole disponibile la bootstrap-it.com.