ProHoster > Blog > Bestjoer > Basisfunksjes fan LXD - Linux-containersystemen

Basisfunksjes fan LXD - Linux-containersystemen

Basisfunksjes fan LXD - Linux-containersystemen

LXD is de folgjende generaasje systeem container manager, sa seit it boarne. It biedt in brûkersynterface fergelykber mei firtuele masines, mar brûkt ynstee Linux-konteners.

LXD kearn is in befoarrjochte daemon (in tsjinst dy't rint mei root-rjochten) dy't in REST API leveret fia in lokale unix-socket, lykas fia it netwurk as de passende konfiguraasje is ynstalleare. Klanten, lykas it kommandorigelark dat is foarsjoen fan LXD, meitsje oanfragen fia dizze REST API. Dit betsjut dat of jo tagong krije ta in lokale host of in host op ôfstân, alles wurket itselde.

Yn dit artikel sille wy net yn detail wenje oer de konsepten fan LXD, wy sille net alle beskikbere mooglikheden beskôgje dy't yn 'e dokumintaasje beskreaun binne, ynklusyf de resinte ymplemintaasje yn' e lêste ferzjes fan LXD fan stipe foar QEMU firtuele masines parallel mei konteners. Ynstee dêrfan sille wy gewoan de basis leare fan kontenerbehear - opslachpools ynstelle, netwurkjen, in kontener útfiere, boarnegrinzen tapasse, en hoe't jo snapshots kinne brûke, sadat jo in basisbegryp fan LXD kinne krije en konteners op Linux kinne brûke.

Foar folsleine ynformaasje, ferwize nei de offisjele boarne:

Navigaasje

Ynstallaasje LXD ^

LXD ynstalleare op Ubuntu-distribúsjes ^

Yn it Ubuntu 19.10-distribúsjepakket lxd hat in útstjoering oan snap pakket:

apt search lxd

lxd/eoan 1:0.7 all
  Transitional package - lxd -> snap (lxd)

Dit betsjut dat twa pakketten tagelyk ynstalleare wurde, ien as in systeempakket en de oare as in snappakket. It ynstallearjen fan twa pakketten op in systeem kin wat probleem meitsje wêrby't it systeempakket wees wurde kin as it snappakket fuorthelle wurdt troch de snappakketbehearder.

Fyn pakket lxd yn it snap repository kinne jo it folgjende kommando brûke:

snap find lxd

Name             Version        Summary
lxd              3.21           System container manager and API
lxd-demo-server  0+git.6d54658  Online software demo sessions using LXD
nova             ocata          OpenStack Compute Service (nova)
nova-hypervisor  ocata          OpenStack Compute Service - KVM Hypervisor (nova)
distrobuilder    1.0            Image builder for LXC and LXD
fabrica          0.1            Build snaps by simply pointing a web form to...
satellite        0.1.2          Advanced scalable Open source intelligence platform

Troch it kommando út te fieren list kinne jo derfoar soargje dat it pakket lxd noch net ynstallearre:

snap list

Name  Version    Rev   Tracking  Publisher   Notes
core  16-2.43.3  8689  stable    canonical✓  core

Nettsjinsteande it feit dat LXD in snappakket is, moat it ynstalleare wurde fia it systeempakket lxd, dat sil meitsje de oerienkommende groep yn it systeem, de nedige nutsbedriuwen yn /usr/bin en sa fierder.

sudo apt update
sudo apt install lxd

Litte wy derfoar soargje dat it pakket is ynstalleare as in snappakket:

snap list

Name  Version    Rev    Tracking  Publisher   Notes
core  16-2.43.3  8689   stable    canonical✓  core
lxd   3.21       13474  stable/…  canonical✓  -

LXD ynstallearje op Arch Linux-distribúsjes ^

Om it LXD-pakket op it systeem te ynstallearjen, moatte jo de folgjende kommando's útfiere, de earste sil de list mei pakketten bywurkje op it systeem beskikber yn it repository, de twadde sil it pakket direkt ynstallearje:

sudo pacman -Syyu && sudo pacman -S lxd

Nei it ynstallearjen fan it pakket, om LXD te behearjen troch in gewoane brûker, moat it wurde tafoege oan de systeemgroep lxd:

sudo usermod -a -G lxd user1

Lit ús soargje dat de brûker user1 tafoege oan groep lxd:

id -Gn user1

user1 adm dialout cdrom floppy sudo audio dip video plugdev netdev lxd

As de groep lxd is net sichtber yn 'e list, dan moatte jo de brûkerssesje opnij aktivearje. Om dit te dwaan, moatte jo útlogge en ynlogge ûnder deselde brûker.

Aktivearje yn systemd it laden fan de LXD-tsjinst by it opstarten fan it systeem:

sudo systemctl enable lxd

Litte wy de tsjinst begjinne:

sudo systemctl start lxd

Kontrolearje de tsjinststatus:

sudo systemctl status lxd

Storage LXD (Opslach) ^

Foardat inisjalisaasje begjint, moatte wy begripe hoe't de opslach yn LXD logysk regele is.

Opslach (Opslach) bestiet út fan ien of mear opslach pool dy't ien fan 'e stipe triemsystemen brûkt lykas ZFS, BTRFS, LVM of reguliere mappen. Elk opslach pool is ferdield yn dielen (Opslach folume) dy't ôfbyldings, konteners of gegevens befetsje foar oare doelen.

  • Ofbyldings - dit binne spesjaal gearstalde distribúsjes sûnder de Linux-kernel en beskikber fan eksterne boarnen
  • Containers - dit binne ynset distribúsjes fan ôfbyldings, klear foar gebrûk
  • Snapshots - dit binne snapshots fan 'e steat fan konteners wêr't jo nei werom kinne

Basisfunksjes fan LXD - Linux-containersystemen

Om opslach yn LXD te behearjen, brûk it kommando lxc storage in sertifikaat wêrfoar jo kinne krije troch it opjaan fan de kaai - lxc storage --help

It folgjende kommando toant in list fan allegear opslach pool yn LXD opslach:

lxc storage list

+---------+-------------+--------+--------------------------------+---------+
|  NAME   | DESCRIPTION | DRIVER |             SOURCE             | USED BY |
+---------+-------------+--------+--------------------------------+---------+
| hddpool |             | btrfs  | /dev/loop1                     | 2       |
+---------+-------------+--------+--------------------------------+---------+
| ssdpool |             | btrfs  | /var/lib/lxd/disks/ssdpool.img | 4       |
+---------+-------------+--------+--------------------------------+---------+

Om in list fan allegear te besjen Opslach folume yn de selektearre opslach pool tsjinnet it team lxc storage volume list:

lxc storage volume list hddpool

+-------+----------------------------------+-------------+---------+
| TYPE  |          NAME                    | DESCRIPTION | USED BY |
+-------+----------------------------------+-------------+---------+
| image | ebd565585223487526ddb3607f515... |             | 1       |
+-------+----------------------------------+-------------+---------+

lxc storage volume list ssdpool

+-----------+----------------------------------+-------------+---------+
|   TYPE    |            NAME                  | DESCRIPTION | USED BY |
+-----------+----------------------------------+-------------+---------+
| container | alp3                             |             | 1       |
+-----------+----------------------------------+-------------+---------+
| container | jupyter                          |             | 1       |
+-----------+----------------------------------+-------------+---------+
| image     | ebd565585223487526ddb3607f515... |             | 1       |
+-----------+----------------------------------+-------------+---------+

Ek, as foar opslach pool By it oanmeitsjen waard it BTRFS-bestânsysteem selektearre, krij dan in list Opslach folume of subvolumes yn 'e BTRFS-ynterpretaasje kinne jo de toolkit fan dit bestânsysteem brûke:

sudo btrfs subvolume list -p /var/lib/lxd/storage-pools/hddpool

ID 257 gen 818 parent 5 top level 5 path images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3

sudo btrfs subvolume list -p /var/lib/lxd/storage-pools/ssdpool

ID 257 gen 1820 parent 5 top level 5 path images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
ID 260 gen 1819 parent 5 top level 5 path containers/jupyter
ID 263 gen 1820 parent 5 top level 5 path containers/alp3

Inisjalisearjen fan LXD ^

Foardat jo konteners oanmeitsje en brûke, moatte jo in algemiene LXD-initialisaasje útfiere dy't it netwurk en opslach oanmakket en konfigurearret. Dit kin mei de hân dien wurde mei standert kliïntkommando's dy't beskikber binne yn 'e list troch it kommando op te roppen lxc --help of mei help fan de inisjalisaasje wizard lxd init in pear fragen beantwurdzje.

Selektearje in triemsysteem foar Storage Pool ^

Tidens inisjalisaasje stelt LXD ferskate fragen, ynklusyf it bepalen fan it bestânssysteemtype foar de standert opslach pool. Standert is it BTRFS-bestânsysteem dêrfoar selektearre. It sil ûnmooglik wêze om te feroarjen nei in oare FS nei skepping. Om in FS te selektearjen wurdt foarsteld feature ferliking tabel:

Eigenskip
Directory
btrfs
LVM
ZFS
CEPH

Optimalisearre ôfbylding opslach
nee
ja
ja
ja
ja

Optimalisearre eksimplaar oanmeitsjen
nee
ja
ja
ja
ja

Optimalisearre snapshot oanmeitsjen
nee
ja
ja
ja
ja

Optimalisearre ôfbylding oerdracht
nee
ja
nee
ja
ja

Optimalisearre eksimplaar oerdracht
nee
ja
nee
ja
ja

Kopiearje op skriuwen
nee
ja
ja
ja
ja

Block basearre
nee
nee
ja
nee
ja

Instant cloning
nee
ja
ja
ja
ja

Storage driver brûkber binnen in kontener
ja
ja
nee
nee
nee

Weromsette fan âldere snapshots (net lêste)
ja
ja
ja
nee
ja

Opslach kwota
Ja(*)
ja
ja
ja
nee

Inisjalisearjen fan it netwurk en Storage Pool mei help fan de wizard ^

It folgjende kommando dat wy sille besjen suggerearret it ynstellen fan de haadkomponinten fan LXD troch ienfâldige fragen te beantwurdzjen mei de inisjalisaasjewizard.

Kommando útfiere lxc init en fier de antwurden yn op 'e fragen nei de kolon lykas werjûn yn it foarbyld hjirûnder of feroarje se neffens jo betingsten:

lxd init

Would you like to use LXD clustering? (yes/no) [default=no]: 
Do you want to configure a new storage pool? (yes/no) [default=yes]: 
Name of the new storage pool [default=default]: ssdpool         
Name of the storage backend to use (lvm, btrfs, dir) [default=btrfs]: 
Create a new BTRFS pool? (yes/no) [default=yes]: 
Would you like to use an existing block device? (yes/no) [default=no]: 
Size in GB of the new loop device (1GB minimum) [default=15GB]: 10GB
Would you like to connect to a MAAS server? (yes/no) [default=no]: 
Would you like to create a new local network bridge? (yes/no) [default=yes]: 
What should the new bridge be called? [default=lxdbr0]: 
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: 10.0.5.1/24
Would you like LXD to NAT IPv4 traffic on your bridge? [default=yes]: 
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: none
Would you like LXD to be available over the network? (yes/no) [default=no]: 
Would you like stale cached images to be updated automatically? (yes/no) [default=yes] no
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]:

It meitsjen fan in ekstra Storage Pool ^

Yn 'e foarige stap hawwe wy makke opslach pool dy't de namme krige ssdpool en it bestân wêrfan op myn systeem leit op /var/lib/lxd/disks/ssdpool.img. Dit triemsysteemadres komt oerien mei it fysike SSD-stasjon op myn PC.

De folgjende aksjes, te wreidzjen begryp fan 'e rol spile troch opslach pool yn it repository sille wy in twadde meitsje opslach pool dy't fysyk sil lizze op in oar type skiif, HDD. It probleem is dat LXD jo net tastean om te meitsjen opslach pool út adres /var/lib/lxd/disks/ en sels symboalyske keppelings sille net wurkje, sjoch it antwurd fan de ûntwikkelder. Wy kinne dizze beheining omgean by inisjalisaasje / opmaak opslach pool troch it opjaan fan de wearde as in blok apparaat ynstee fan it paad nei de loopback triem troch opjaan dit yn de kaai source.

Dus, foardat jo meitsje opslach pool jo moatte in loopback-bestân definiearje as in besteande partysje op jo bestânsysteem dat it sil brûke. Om dit te dwaan, sille wy in bestân oanmeitsje en brûke dat wy yn grutte sille beheine ta 10GB:

dd if=/dev/zero of=/mnt/work/lxd/hddpool.img bs=1MB count=10000

10000+0 records in
10000+0 records out
10000000000 bytes (10 GB, 9,3 GiB) copied, 38,4414 s, 260 MB/s

Litte wy it loopback-bestân ferbine mei in fergese loopback-apparaat:

sudo losetup --find --show /mnt/work/lxd/hddpool.img

/dev/loop1

Mei tank oan de kaai --show it útfieren fan it kommando jout werom nei it skerm de namme fan it apparaat wêryn ús loopback-bestân is ferbûn. As it nedich is, kinne wy ​​in list sjen litte fan alle drokke apparaten fan dit type om te soargjen dat ús aksjes korrekt binne:

losetup -l

NAME       SIZELIMIT OFFSET AUTOCLEAR RO BACK-FILE                      DIO LOG-SEC
/dev/loop1         0      0         0  0 /mnt/work/lxd/hddpool.img        0     512
/dev/loop0         0      0         1  0 /var/lib/lxd/disks/ssdpool.img   0     512

Ut de list kinne jo fine dat it apparaat hat /dev/loop1 loopback-bestân ynbegrepen /mnt/work/lxd/hddpool.img, en yn it apparaat /dev/loop0 loopback-bestân ynbegrepen /var/lib/lxd/disks/ssdpool.img dy't oerienkomt mei de standert opslach pool.

It folgjende kommando makket in nij opslach pool yn LXD basearre op it loopback-bestân dat wy krekt taret hawwe. LXD sil it loopback-bestân formatearje /mnt/work/lxd/hddpool.img yn it apparaat /dev/loop1 foar it BTRFS-bestânsysteem:

lxc storage create hddpool btrfs size=10GB source=/dev/loop1

Litte wy in list fan allegear sjen litte opslach pool nei skerm:

lxc storage list

+---------+-------------+--------+--------------------------------+---------+
|  NAME   | DESCRIPTION | DRIVER |             SOURCE             | USED BY |
+---------+-------------+--------+--------------------------------+---------+
| hddpool |             | btrfs  | /dev/loop1                     | 0       |
+---------+-------------+--------+--------------------------------+---------+
| ssdpool |             | btrfs  | /var/lib/lxd/disks/ssdpool.img | 0       |
+---------+-------------+--------+--------------------------------+---------+

It fergrutsjen fan de Storage Pool Grutte ^

Nei skepping opslach pool, as it nedich is, kin útwreide wurde. Foar opslach pool basearre op it BTRFS-bestânsysteem, fier de folgjende kommando's út:

sudo truncate -s +5G /mnt/work/lxd/hddpool.img
sudo losetup -c /dev/loop1
sudo btrfs filesystem resize max /var/lib/lxd/storage-pools/hddpool

Auto ynfoegje fan in loopback triem yn in loopback apparaat slot ^

Wy hawwe ien lyts probleem, by it opnij opstarten fan it hostsysteem, it bestân /mnt/work/lxd/hddpool.img sil "fleane" út it apparaat /dev/loop1 en de LXD-tsjinst sil crashe by it laden, om't it it net sil sjen yn dit apparaat. Om dit probleem op te lossen moatte jo in systeemtsjinst oanmeitsje dy't dit bestân yn it apparaat sil ynfoegje /dev/loop1 as it hostsysteem opstart.

Lit ús meitsje ienheid triemtype betsjinning в /etc/systemd/system/ foar it SystemD inisjalisaasjesysteem:

cat << EOF | sudo tee -a /etc/systemd/system/lxd-hddpool.service
[Unit]
Description=Losetup LXD Storage Pool (hddpool)
After=local-fs.target

[Service]
Type=oneshot
ExecStart=/sbin/losetup /dev/loop1 /mnt/work/lxd/hddpool.img
RemainAfterExit=true

[Install]
WantedBy=local-fs.target
EOF

Aktivearje de tsjinst:

sudo systemctl enable lxd-hddpool

Created symlink /etc/systemd/system/local-fs.target.wants/lxd-hddpool.service → /etc/systemd/system/lxd-hddpool.service.

Nei it opnij starte fan it hostsysteem kontrolearje wy de tsjinststatus:

systemctl status lxd-hddpool.service 

● lxd-hddpool.service - Losetup LXD Storage Pool (hddpool)
     Loaded: loaded (/etc/systemd/system/lxd-hddpool.service; enabled; vendor preset: disabled)
     Active: active (exited) since Wed 2020-04-08 03:43:53 MSK; 1min 37s ago
    Process: 711 ExecStart=/sbin/losetup /dev/loop1 /mnt/work/lxd/hddpool.img (code=exited, status=0/SUCCESS)
   Main PID: 711 (code=exited, status=0/SUCCESS)

апр 08 03:43:52 manjaro systemd[1]: Starting Losetup LXD Storage Pool (hddpool)...
апр 08 03:43:53 manjaro systemd[1]: Finished Losetup LXD Storage Pool (hddpool).

Fanút de útfier kinne wy ​​​​ferifiearje dat de tsjinststatus is aktyf, nettsjinsteande it feit dat de útfiering fan ús skript fan ien kommando foltôge wie, liet de opsje ús dit dwaan RemainAfterExit=true.

Feilichheid. Container Privileges ^

Sûnt alle kontenerprosessen eins yn isolaasje rinne op it hostsysteem mei syn kernel, om de tagong fan kontenerprosessen nei it hostsysteem fierder te beskermjen, biedt LXD prosesprivilege, wêrby't:

  • Privilearde konteners - dit binne konteners wêryn prosessen mei UID en GID oerienkomme mei deselde eigner as op it hostsysteem. Bygelyks, in proses dat rint yn in kontener mei in UID fan 0 hat alle deselde tagongsrjochten as in proses op it hostsysteem mei in UID fan 0. Mei oare wurden, de root-brûker yn 'e kontener hat alle rjochten net allinich yn de kontener, mar ek op de host systeem as hy kin gean bûten de container syn isolearre nammeromte.

  • Unprivilegearre konteners - dit binne konteners wêryn prosessen hearre ta de eigner fan 'e UID en GID mei in nûmer fan 0 oant 65535, mar foar it hostsysteem wurdt de eigner maskearre mei respektivelik de tafoege SubUID- en SubGID-bits. Bygelyks, in brûker mei UID = 0 yn in kontener sil sjoen wurde op de host systeem as SubUID + UID. Dit beskermet it hostsysteem, om't as ien proses yn 'e kontener syn isolearre nammeromte kin ûntkomme, kin it allinich kommunisearje mei it hostsysteem as in proses mei in ûnbekende, heul hege UID / GID.

Standert hawwe nij oanmakke konteners in unprivileged status en dêrom moatte wy in SubUID en SubGID definiearje.

Litte wy twa konfiguraasjebestannen oanmeitsje wêryn wy it masker foar respektivelik SubUID en SubGID sille ynstelle:

sudo touch /etc{/subuid,/subgid}
sudo usermod --add-subuids 1000000-1065535 root 
sudo usermod --add-subgids 1000000-1065535 root

Om de wizigingen oan te passen, moat de LXD-tsjinst opnij starte:

sudo systemctl restart lxd

It meitsjen fan in firtuele netwurk switch ^

Sûnt wy earder inisjalisearre it netwurk mei help fan de inisjalisaasje wizard lxd init en makke in netwurk apparaat lxdbr0, dan sille wy yn dizze seksje gewoan yn 'e kunde komme mei netwurken yn LXD en hoe't jo in firtuele skeakel (brêge) meitsje kinne mei it kliïntkommando.

It folgjende diagram lit sjen hoe't in switch (brêge) de host en konteners ferbynt yn in netwurk:

Basisfunksjes fan LXD - Linux-containersystemen

Containers kinne fia in netwurk kommunisearje mei oare konteners as de host wêrop dizze konteners wurde betsjinne. Om dit te dwaan, moatte jo de firtuele netwurkkaarten fan 'e konteners keppelje mei in firtuele switch. Wy sille earst in skeakel oanmeitsje, en de netwurkynterfaces fan 'e kontener wurde keppele yn folgjende haadstikken, nei't de kontener sels oanmakke is.

It folgjende kommando makket in skeakel mei in subnet 10.0.5.0/24 en IPv4-adres 10.0.5.1/24, en ek omfettet ipv4.nat sadat konteners tagong kinne ta it ynternet fia de host mei de NAT-tsjinst:

lxc network create lxdbr0 ipv4.address=10.0.5.1/24 ipv4.nat=true ipv6.address=none

Kontrolearje de list mei netwurkapparaten beskikber yn LXD:

lxc network list

+--------+----------+---------+-------------+---------+
|  NAME  |   TYPE   | MANAGED | DESCRIPTION | USED BY |
+--------+----------+---------+-------------+---------+
| eno1   | physical | NO      |             | 0       |
+--------+----------+---------+-------------+---------+
| lxdbr0 | bridge   | YES     |             | 0       |
+--------+----------+---------+-------------+---------+

Jo kinne ek ferifiearje dat in netwurkapparaat is makke mei it standert ark fan 'e Linux-distribúsje - ip link of ip addr:

ip addr

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: eno1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether bc:ee:7b:5a:6b:44 brd ff:ff:ff:ff:ff:ff
    altname enp0s25
    inet6 fe80::9571:11f3:6e0c:c07b/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever
3: lxdbr0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
    link/ether c2:38:90:df:cb:59 brd ff:ff:ff:ff:ff:ff
    inet 10.0.5.1/24 scope global lxdbr0
       valid_lft forever preferred_lft forever
    inet6 fe80::c038:90ff:fedf:cb59/64 scope link 
       valid_lft forever preferred_lft forever
5: veth3ddab174@if4: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master lxdbr0 state UP group default qlen 1000
    link/ether ca:c3:5c:1d:22:26 brd ff:ff:ff:ff:ff:ff link-netnsid 0

Konfiguraasjeprofyl ^

Elke kontener yn LXD hat syn eigen konfiguraasje en kin it útwreidzje mei globaal ferklearre konfiguraasjes neamd konfiguraasje profilen. It tapassen fan konfiguraasjeprofilen op in kontener hat in kaskademodel, it folgjende foarbyld lit dit sjen:

Basisfunksjes fan LXD - Linux-containersystemen

Yn dit foarbyld binne trije profilen makke yn it LXD-systeem: default, hddpool и hostfs. Alle trije profilen wurde tapast op in kontener dy't in lokale konfiguraasje hat (griis gebiet). Profyl default hat in apparaat root dy't in parameter hat pool is gelyk oan ssdpool, mar tank oan de cascade konfiguraasje applikaasje model, kinne wy ​​tapasse in profyl oan de kontener hddpool dy't in parameter hat pool sil deselde parameter oerskriuwe fan it profyl default en de kontener sil de apparaatkonfiguraasje ûntfange root mei parameter pool lykweardich hddpool, en it profyl hostfs foeget gewoan in nij apparaat ta oan 'e kontener.

Om de list mei beskikbere konfiguraasjeprofilen te sjen, brûk it folgjende kommando:

lxc profile list

+---------+---------+
|  NAME   | USED BY |
+---------+---------+
| default | 1       |
+---------+---------+
| hddroot | 0       |
+---------+---------+
| ssdroot | 1       |
+---------+---------+

In folsleine list mei beskikbere kommando's foar wurkjen mei in profyl kin wurde krigen troch de kaai ta te foegjen --help:

lxc profile --help

Description:
  Manage profiles

Usage:
  lxc profile [command]

Available Commands:
  add         Add profiles to instances
  assign      Assign sets of profiles to instances
  copy        Copy profiles
  create      Create profiles
  delete      Delete profiles
  device      Manage instance devices
  edit        Edit profile configurations as YAML
  get         Get values for profile configuration keys
  list        List profiles
  remove      Remove profiles from instances
  rename      Rename profiles
  set         Set profile configuration keys
  show        Show profile configurations
  unset       Unset profile configuration keys

Jo profyl bewurkje ^

Standert konfiguraasje profyl default hat gjin netwurkkaartkonfiguraasje foar de kontener en alle nij oanmakke konteners hawwe gjin netwurk, foar har is it nedich om lokale (tawiide) netwurkapparaten te meitsjen mei in apart kommando, mar wy kinne in wrâldwide netwurkapparaat yn 'e konfiguraasje meitsje profyl dat dield wurdt tusken alle konteners dy't dit profyl brûke. Op dizze manier, fuortendaliks nei it kommando om in nije kontener te meitsjen, sille se in netwurk hawwe mei netwurk tagong. Tagelyk binne d'r gjin beheiningen; wy kinne letter altyd in lokaal netwurkapparaat meitsje as it nedich is.

It folgjende kommando sil it apparaat tafoegje oan it konfiguraasjeprofyl eth0 type nic ferbûn mei it netwurk lxdbr0:

lxc profile device add default eth0 nic network=lxdbr0 name=eth0

It is wichtich om te notearjen dat, om't wy it apparaat feitlik tafoege oan it konfiguraasjeprofyl, as wy in statysk IP-adres yn it apparaat oantsjutte, dan sille alle konteners dy't dit profyl brûke itselde IP-adres diele. As d'r needsaak is om in kontener te meitsjen mei in statysk IP-adres tawiisd foar de kontener, dan moatte jo in netwurkapparaatkonfiguraasje oanmeitsje op it kontenernivo (lokale konfiguraasje) mei de IP-adresparameter, en net op it profylnivo.

Litte wy it profyl kontrolearje:

lxc profile show default

config: {}
description: Default LXD profile
devices:
  eth0:
    name: eth0
    network: lxdbr0
    type: nic
  root:
    path: /
    pool: ssdpool
    type: disk
name: default
used_by: []

Yn dit profyl kinne wy ​​sjen dat foar alle nij oanmakke konteners twa apparaten sille wurde oanmakke:

  • eth0 - Type apparaat nic ferbûn mei in switch (netwurkbrêge) lxdbr0
  • root - Type apparaat disk dy't brûkt in opslach pool ssdpool

It meitsjen fan nije profilen ^

Om earder makke te brûken opslach pool containers, meitsje in konfiguraasje profyl ssdroot wêryn wy sille tafoegje in apparaat lykas disk mei mount punt / (root) mei help fan de earder makke opslach pool - ssdpool:

lxc profile create ssdroot
lxc profile device add ssdroot root disk path=/ pool=ssdpool

Op deselde manier meitsje wy in apparaat lykas disk, mar yn dit gefal mei help opslach pool - hddpool:

lxc profile create hddroot
lxc profile device add hddroot root disk path=/ pool=hddpool

Konfiguraasjeprofilen kontrolearje:

lxc profile show ssdroot

config: {}
description: ""
devices:
  root:
    path: /
    pool: ssdpool
    type: disk
name: ssdroot
used_by: []

lxc profile show hddroot

config: {}
description: ""
devices:
  root:
    path: /
    pool: hddpool
    type: disk
name: hddroot
used_by: []

Ofbylding repository ^

Containers wurde makke fan ôfbyldings dy't spesjaal gearstalde distribúsjes binne dy't gjin Linux-kernel hawwe. Dêrom, foardat it útfieren fan de kontener, moat it wurde ynset fan dizze ôfbylding. De boarne fan ôfbyldings is in lokale repository wêryn ôfbyldings wurde ynladen fan eksterne repositories.

Remote image repositories ^

Standert is LXD konfigurearre om ôfbyldings te ûntfangen fan trije boarnen op ôfstân:

  • ubuntu: (foar stabile Ubuntu-ôfbyldings)
  • ubuntu-dei: (foar deistige Ubuntu-ôfbyldings)
  • ôfbyldings: (foar in boskje oare distros)

lxc remote list

+-----------------+------------------------------------------+--------+--------+
|      NAME       |                   URL                    | PUBLIC | STATIC |
+-----------------+------------------------------------------+--------+--------+
| images          | https://images.linuxcontainers.org       | YES    | NO     |
+-----------------+------------------------------------------+--------+--------+
| local (default) | unix://                                  | NO     | YES    |
+-----------------+------------------------------------------+--------+--------+
| ubuntu          | https://cloud-images.ubuntu.com/releases | YES    | YES    |
+-----------------+------------------------------------------+--------+--------+
| ubuntu-daily    | https://cloud-images.ubuntu.com/daily    | YES    | YES    |
+-----------------+------------------------------------------+--------+--------+

Bygelyks, repository ubuntu: hat de folgjende ôfbyldings:

lxc image -c dasut list ubuntu: | head -n 11

+----------------------------------------------+--------------+----------+------------+
|                   DESCRIPTION                | ARCHITECTURE |   SIZE   |   TYPE     |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150728)  | x86_64       | 153.72MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150819)  | x86_64       | 152.91MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150906)  | x86_64       | 154.69MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150930)  | x86_64       | 153.86MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+

Om in beheind oantal kolommen wer te jaan hawwe wy de opsje brûkt -c mei parameters dasut, en ek beheind de lingte fan de list mei it kommando head.

Filtering is beskikber om in list mei ôfbyldings wer te jaan. It folgjende kommando sil alle beskikbere distribúsje-arsjitekten listje AlpineLinux:

lxc image -c ldast list images:alpine/3.11

+------------------------------+--------------------------------------+--------------+
|            ALIAS             |             DESCRIPTION              | ARCHITECTURE |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11 (3 more)         | Alpine 3.11 amd64 (20200220_13:00)   | x86_64       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/arm64 (1 more)   | Alpine 3.11 arm64 (20200220_13:00)   | aarch64      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/armhf (1 more)   | Alpine 3.11 armhf (20200220_13:00)   | armv7l       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/i386 (1 more)    | Alpine 3.11 i386 (20200220_13:01)    | i686         |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/ppc64el (1 more) | Alpine 3.11 ppc64el (20200220_13:00) | ppc64le      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/s390x (1 more)   | Alpine 3.11 s390x (20200220_13:00)   | s390x        |
+------------------------------+--------------------------------------+--------------+

Lokale ôfbyldingsrepository ^

Om de kontener te brûken, moatte jo in ôfbylding tafoegje fan it globale repository oan 'e lokale local:. No is it lokale repository leech, it kommando sil der wis fan wêze lxc image list. As de metoade list spesifisearje gjin repository, dan sil it lokale repository standert brûkt wurde - local:

lxc image list local:

+-------+-------------+--------+-------------+--------------+------+------+
| ALIAS | FINGERPRINT | PUBLIC | DESCRIPTION | ARCHITECTURE | TYPE | SIZE |
+-------+-------------+--------+-------------+--------------+------+------+

Ofbyldings yn it repository wurde beheard mei de folgjende metoaden:

team
beskriuwing

lxc ôfbylding alias
Beheare ôfbylding aliassen

lxc ôfbylding copy
Kopiearje ôfbyldings tusken servers

lxc ôfbylding wiskje
Ofbyldings wiskje

lxc ôfbylding bewurkje seksje
Bewurkje ôfbylding eigenskippen

lxc ôfbylding eksportearje
Ofbyldings eksportearje en downloade

lxc ôfbylding Ymportearje
Ymportearje ôfbyldings yn 'e ôfbyldingswinkel

lxc ôfbylding info
Lit nuttige ynformaasje oer ôfbyldings sjen

lxc ôfbylding list
List ôfbyldings

lxc ôfbylding opfrisse
Ofbyldings ferfarskje

lxc ôfbylding show
Lit ôfbylding eigenskippen sjen

Kopiearje de ôfbylding nei it lokale repository fan 'e globale images::

lxc image copy images:alpine/3.11/amd64 local: --alias=alpine3

Image copied successfully!

Litte wy in list sjen litte fan alle ôfbyldings dy't op it stuit beskikber binne yn it lokale repository local::

lxc image -c lfdatsu list local:

+---------+--------------+------------------------------------+--------------+
|  ALIAS  | FINGERPRINT  |            DESCRIPTION             | ARCHITECTURE |
+---------+--------------+------------------------------------+--------------+
| alpine3 | 73a3093d4a5c | Alpine 3.11 amd64 (20200220_13:00) | x86_64       |
+---------+--------------+------------------------------------+--------------+

LXD konfiguraasje ^

Neist de ynteraktive modus stipet LXD ek in net-ynteraktive konfiguraasje-ynstallaasjemodus, dit is as de konfiguraasje wurdt oantsjutte yn 'e foarm fan in YAML-bestân, in spesjale opmaak wêrmei jo de folsleine konfiguraasje tagelyk kinne ynstallearje, de útfiering foarby gean. fan in protte ynteraktive kommando's dy't hjirboppe yn dit artikel waarden besprutsen, ynklusyf netwurkkonfiguraasje, oanmeitsjen fan konfiguraasjeprofilen, ensfh. Wy sille dit gebiet hjir net dekke, jo kinne it sels kontrolearje. yn dokumintaasje.

Folgjende ynteraktive kommando lxc config wêr't wy nei sille sjen kinne jo de konfiguraasje ynstelle. Bygelyks, om te soargjen dat ynladen ôfbyldings nei it lokale repository net automatysk bywurke wurde fan 'e globale repositories, kinne wy ​​dit gedrach ynskeakelje mei it folgjende kommando:

lxc config set images.auto_update_cached=false

It oanmeitsjen en behearen fan in kontener ^

Om in kontener te meitsjen brûk it kommando lxc init dêr't wearden oan wurde trochjûn репозиторий:образ en dan de winske ID foar de kontener. De repository kin wurde oantsjutte as lokaal local: sa is elke globale ien. As de repository net oantsjutte is, dan wurdt standert de lokale repository brûkt om te sykjen nei de ôfbylding. As de ôfbylding wurdt oantsjutte út it globale repository, dan sil de ôfbylding earst wurde ynladen nei it lokale repository en dan brûkt om de kontener te meitsjen.

Litte wy it folgjende kommando útfiere om ús earste kontener te meitsjen:

lxc init alpine3 alp --storage=hddpool --profile=default --profile=hddroot

Litte wy nei de kommando-kaaien sjen dy't wy hjir brûke yn folchoarder:

  • alpine3 - In alias (alias) is spesifisearre foar de ôfbylding dy't earder waard upload nei it lokale repository. As de alias net makke is foar dizze ôfbylding, dan kinne jo altyd ferwize nei de ôfbylding troch syn Fingerprint dat wurdt werjûn yn 'e tabel.
  • alp - Stelt de identifier yn foar de kontener
  • --storage - Dizze kaai jout oan wêryn opslach pool in kontener sil oanmakke wurde
  • --profile - Dizze kaaien kaskade tapasse konfiguraasje fan earder oanmakke konfiguraasjeprofilen op 'e kontener

Wy lansearje de kontener, dy't it initsysteem fan 'e distribúsje begjint te starten:

lxc start alp

Jo kinne ek it kommando brûke lxc launch wêrtroch jo teams kinne kombinearje lxc init и lxc start yn ien operaasje.

Kontrolearje de steat fan 'e kontener:

lxc list -c ns46tb
+------+---------+------------------+------+-----------+--------------+
| NAME |  STATE  |       IPV4       | IPV6 |   TYPE    | STORAGE POOL |
+------+---------+------------------+------+-----------+--------------+
| alp  | RUNNING | 10.0.5.46 (eth0) |      | CONTAINER | hddpool      |
+------+---------+------------------+------+-----------+--------------+

Kontrolearje de kontenerkonfiguraasje:

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200326_13:39)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200326_13:39"
  image.type: squashfs
  volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
  volatile.eth0.host_name: vethb1fe71d8
  volatile.eth0.hwaddr: 00:16:3e:5f:73:3e
  volatile.idmap.base: "0"
  volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.power: RUNNING
devices:
  root:
    path: /
    pool: hddpool
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

Yn de seksje profiles wy kinne derfoar soargje dat dizze kontener twa konfiguraasjeprofilen brûkt - default и hddroot. Yn seksje devices wy kinne mar ien apparaat ûntdekke, om't it netwurkapparaat op it profylnivo makke is default. Om alle apparaten te sjen dy't troch de kontener brûkt wurde, moatte jo in kaai tafoegje --expanded:

lxc config show alp --expanded

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200326_13:39)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200326_13:39"
  image.type: squashfs
  volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
  volatile.eth0.host_name: vethb1fe71d8
  volatile.eth0.hwaddr: 00:16:3e:5f:73:3e
  volatile.idmap.base: "0"
  volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.power: RUNNING
devices:
  eth0:
    name: eth0
    network: lxdbr0
    type: nic
  root:
    path: /
    pool: hddpool
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

It ynstellen fan in statysk IP-adres ^

As wy besykje in IP-adres yn te stellen foar in netwurkapparaat eth0 ploech lxc config device set alp bedoeld foar de kontenerkonfiguraasje, dan krije wy in flater dy't rapportearret dat it apparaat net bestiet omdat it apparaat eth0 dat wurdt brûkt troch de kontener heart ta it profyl default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Wy kinne fansels in statysk IP-adres ynstelle foar eth0 apparaten yn it profyl, mar it sil itselde wêze foar alle konteners dy't dit profyl brûke. Litte wy dêrom in apparaat tafoegje wijd oan 'e kontener:

lxc config device add alp eth0 nic name=eth0 nictype=bridged parent=lxdbr0 ipv4.address=10.0.5.5

Dan moatte jo de kontener opnij starte:

lxc restart alp

As wy no nei de kontenerkonfiguraasje sjogge, hoege wy de opsje net te brûken --expanded om it netwurkapparaat te sjen eth0, om't wy it makke hawwe op it kontenernivo en it kaskade oer itselde apparaat fan it profyl default:

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200326_13:39)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200326_13:39"
  image.type: squashfs
  volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
  volatile.eth0.host_name: veth2a1dc59d
  volatile.eth0.hwaddr: 00:16:3e:0e:e2:71
  volatile.idmap.base: "0"
  volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.power: RUNNING
devices:
  eth0:
    ipv4.address: 10.0.5.5
    name: eth0
    nictype: bridged
    parent: lxdbr0
    type: nic
  root:
    path: /
    pool: hddpool
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

It fuortsmiten fan in kontener ^

Om in kontener te ferwiderjen, brûk it kommando lxc delete, mar foardat de kontener fuorthelle wurdt, moat it stoppe wurde mei it kommando lxc stop:

lxc stop alp

lxc list

+------+---------+-------------------+------+-----------+-----------+
| NAME |  STATE  |       IPV4        | IPV6 |   TYPE    | SNAPSHOTS |
+------+---------+-------------------+------+-----------+-----------+
| alp  | STOPPED | 10.0.5.10 (eth0)  |      | CONTAINER | 0         |
+------+---------+-------------------+------+-----------+-----------+

Neidat wy hawwe ferifiearre dat de steat fan de kontener is wurden STOPPED, it kin fuortsmiten wurde fan opslach pool:

lxc delete alp

Container tagong ^

Om kommando's direkt yn in kontener út te fieren, troch netwurkferbiningen te omgean, brûk it kommando lxc exec dy't kommando's yn 'e kontener útfiert sûnder de systeemshell te starten. As jo ​​​​in kommando moatte útfiere yn in shell mei help fan shell-patroanen lykas fariabelen, triemferwizings (pipe), ensfh., Dan moatte jo de shell eksplisyt starte en it kommando trochjaan as in kaai, bygelyks:

lxc exec alp -- /bin/sh -c "echo $HOME"

It kommando brûkte in spesjale escape-karakter foar spesjale karakter $ sadat de fariabele $HOME waard net ynterpretearre op de host masine, mar waard ynterpretearre allinnich binnen de kontener.

It is ek mooglik om de ynteraktive shell-modus te begjinnen, en dan de sesje te beëinigjen troch fluchtoets út te fieren CTRL+D:

lxc exec alp -- /bin/sh

Container boarne behear ^

Yn LXD kinne jo kontenerboarnen beheare mei in spesjale set fan konfiguraasje. In folsleine list mei parameters foar konfiguraasje fan konteners kin fûn wurde yn dokumintaasje.

RAM boarne beheining ^

Parameter limits.memory beheint it bedrach fan RAM beskikber foar de kontener. De wearde is in nûmer en ien fan beskikbere efterheaksels.

Litte wy de RAM-limyt fan 'e kontener ynstelle op 256 MB:

lxc config set alp limits.memory 256MB

Ek binne d'r oare parameters foar it beheinen fan ûnthâld:

  • limits.memory.enforce
  • limits.memory.hugepages
  • limits.memory.swap
  • limits.memory.swap.priority

team lxc config show kinne jo de folsleine kontenerkonfiguraasje werjaan, ynklusyf de tapaste boarnelimyt dy't ynsteld is:

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200220_13:00)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200220_13:00"
  image.type: squashfs
  limits.memory: 256MB
  volatile.base_image: 73a3093d4a5ce0148fd84b95369b3fbecd19a537ddfd2e2d20caa2eef0e8fd60
  volatile.eth0.host_name: veth75b6df07
  volatile.eth0.hwaddr: 00:16:3e:a1:e7:46
  volatile.idmap.base: "0"
  volatile.idmap.current: '[]'
  volatile.idmap.next: '[]'
  volatile.last_state.idmap: '[]'
  volatile.last_state.power: RUNNING
devices: {}
ephemeral: false
profiles:
- default
stateful: false
description: ""

CPU-boarne limyt ^

D'r binne ferskate manieren om CPU-boarnen te beheinen. soarten beheinings:

  • limit.cpu - bynt in kontener oan ien of mear CPU kearnen
  • limits.cpu.allowance - beheart of CFS-planner-kwota's as de tiidlimyt is foarby, of it universele CPU-boarne-dielingsmeganisme as it persintaazje is foarby
  • limits.cpu.priority - plannerprioriteit as meardere eksimplaren dy't in set processors diele, itselde persintaazje processors wurde tawiisd

lxc config set alp limits.cpu.allowance 40%

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200220_13:00)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200220_13:00"
  image.type: squashfs
  limits.cpu.allowance: 40%
  limits.memory: 256MB
  volatile.base_image: 73a3093d4a5ce0148fd84b95369b3fbecd19a537ddfd2e2d20caa2eef0e8fd60
  volatile.eth0.host_name: veth75b6df07
  volatile.eth0.hwaddr: 00:16:3e:a1:e7:46
  volatile.idmap.base: "0"
  volatile.idmap.current: '[]'
  volatile.idmap.next: '[]'
  volatile.last_state.idmap: '[]'
  volatile.last_state.power: RUNNING
devices: {}
ephemeral: false
profiles:
- default
stateful: false
description: ""

Skiifromte beheining ^

Neist beheinings sokke limits.read, limits.write wy kinne ek de hoemannichte skiifromte beheine konsumearre troch de kontener (wurket allinich mei ZFS of BTRFS):

lxc config device set alp root size=2GB

Nei ynstallaasje, yn de parameter devices.root.size Wy kinne de ynstelde limyt ferifiearje:

lxc config show alp
...
devices:
  root:
    path: /
    pool: hddpool
    size: 2GB
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

Om de brûkte skiifkwota's te besjen kinne wy ​​krije fan it kommando lxc info:

lxc info alp
...
Resources:
  Processes: 5
  Disk usage:
    root: 1.05GB
  CPU usage:
    CPU usage (in seconds): 1
  Memory usage:
    Memory (current): 5.46MB
  Network usage:
    eth0:
      Bytes received: 802B
      Bytes sent: 1.59kB
      Packets received: 4
      Packets sent: 14
    lo:
      Bytes received: 0B
      Bytes sent: 0B
      Packets received: 0
      Packets sent: 0

Nettsjinsteande it feit dat wy in limyt hawwe ynsteld foar it root-apparaat fan 'e kontener op 2GB, systeemprogramma's lykas df sil dizze beheining net sjen. Om dit te dwaan, sille wy in lytse test útfiere en útfine hoe't it wurket.

Litte wy 2 nije identike konteners yn deselde meitsje opslach pool (hddpool):

lxc init alpine3 alp1 --storage=hddpool --profile=default --profile=hddroot
lxc init alpine3 alp2 --storage=hddpool --profile=default --profile=hddroot

lxc list
+------+---------+------------------+------+-----------+-----------+
| NAME |  STATE  |       IPV4       | IPV6 |   TYPE    | SNAPSHOTS |
+------+---------+------------------+------+-----------+-----------+
| alp1 | RUNNING | 10.0.5.46 (eth0) |      | CONTAINER | 0         |
+------+---------+------------------+------+-----------+-----------+
| alp2 | RUNNING | 10.0.5.30 (eth0) |      | CONTAINER | 0         |
+------+---------+------------------+------+-----------+-----------+

Litte wy in 1GB-bestân oanmeitsje yn ien fan 'e konteners:

lxc exec alp1 -- dd if=/dev/urandom of=file.img bs=1M count=1000

Litte wy derfoar soargje dat it bestân oanmakke is:

lxc exec alp1 -- ls -lh
total 1000M  
-rw-r--r--    1 root     root     1000.0M Mar 27 10:16 file.img

As wy yn 'e twadde kontener sjogge, kontrolearje dan op it bestean fan in bestân op deselde lokaasje, dan sil dit bestân d'r net wêze, wat ferwachte wurdt, om't konteners yn har eigen makke wurde Opslach folume yn itselde opslach pool:

lxc exec alp2 -- ls -lh
total 0

Mar lit ús de wearden fergelykje dy't it produseart df op ien en oare kontener:

lxc exec alp1 -- df -hT
Filesystem           Type            Size      Used Available Use% Mounted on
/dev/loop1           btrfs           9.3G   1016.4M      7.8G  11% /
...

lxc exec alp2 -- df -hT
Filesystem           Type            Size      Used Available Use% Mounted on
/dev/loop1           btrfs           9.3G   1016.4M      7.8G  11% /
...

Device /dev/loop1 monteare as de root-partysje is opslach pool dy't dizze konteners brûke, sadat se har folume diele tusken twa.

Statistiken oer boarneferbrûk ^

Jo kinne statistiken oer boarneferbrûk besjen foar in kontener mei it kommando:

lxc info alp

Name: alp
Location: none
Remote: unix://
Architecture: x86_64
Created: 2020/04/08 18:05 UTC
Status: Running
Type: container
Profiles: default, hddroot
Pid: 19219
Ips:
  eth0: inet    10.0.5.5        veth2a1dc59d
  eth0: inet6   fe80::216:3eff:fe0e:e271        veth2a1dc59d
  lo:   inet    127.0.0.1
  lo:   inet6   ::1
Resources:
  Processes: 5
  Disk usage:
    root: 495.62kB
  CPU usage:
    CPU usage (in seconds): 1
  Memory usage:
    Memory (current): 4.79MB
  Network usage:
    eth0:
      Bytes received: 730B
      Bytes sent: 1.59kB
      Packets received: 3
      Packets sent: 14
    lo:
      Bytes received: 0B
      Bytes sent: 0B
      Packets received: 0
      Packets sent: 0

Wurkje mei snapshots ^

LXD hat de mooglikheid om snapshots te meitsjen en de kontenerstatus fan har te herstellen.

Om in snapshot te meitsjen, fier it folgjende kommando út:

lxc snapshot alp snapshot1

It team lxc snapshot gjin kaai beskikber list, dêrom, om de list mei snapshots te besjen, moatte jo it kommando brûke dat algemiene ynformaasje oer de kontener toant:

lxc info alp
...
...
Snapshots:
  snapshot1 (taken at 2020/04/08 18:18 UTC) (stateless)

Jo kinne in kontener weromsette fan in momintopname mei it kommando lxc restore spesifisearje de kontener wêrfoar de restauraasje sil wurde útfierd en de snapshot alias:

lxc restore alp snapshot1

It folgjende kommando wurdt brûkt om in snapshot te wiskjen. Tink derom dat de kommandosyntaksis net fergelykber is mei alle oaren; hjir moatte jo in foarútstribjende slash opjaan nei de kontenernamme. As de slash is weilitten, dan wurdt it kommando om in momintopname te wiskjen ynterpretearre as in kommando om in kontener te wiskjen!

lxc delete alp/snapshot1

Yn it foarbyld hjirboppe hawwe wy sjoen nei saneamde stateless snapshots. LXD hat in oar type snapshots - stateful, dy't de aktuele steat fan alle prosessen yn 'e kontener bewarret. D'r binne in oantal nijsgjirrige en nuttige funksjes ferbûn mei stateful snapshots.

Wat oars? ^

  • In module is beskikber foar Python-ûntwikkelders PyLXD dy't in API oan LXD leveret

UPDATE 10.04.2020/15/00 XNUMX:XNUMX: Navigaasje tafoege

Boarne: www.habr.com

Add a comment