ProHoster > Blog > Administratioun > Basis Features vun LXD - Linux Container Systemer

Basis Features vun LXD - Linux Container Systemer

Basis Features vun LXD - Linux Container Systemer

LXD ass déi nächst Generatioun System Container Manager, sou seet et Quell. Et bitt eng User-Interface ähnlech wéi virtuell Maschinnen, awer benotzt Linux Container amplaz.

LXD Kär ass e privilegiéierten Daemon (e Service deen mat Root Rechter leeft) deen e REST API iwwer e lokalen Unix Socket ubitt, souwéi iwwer de Reseau wann déi entspriechend Konfiguratioun installéiert ass. Clienten, sou wéi de Kommandozeil-Tool mat LXD geliwwert, maachen Ufroen duerch dës REST API. Dëst bedeit datt egal ob Dir op e lokale Host oder e Fernhost gitt, alles funktionnéiert d'selwecht.

An dësem Artikel wäerte mir net am Detail op d'Konzepter vun LXD wunnen, mir wäerten net all déi verfügbar Fäegkeeten berücksichtegen, déi an der Dokumentatioun duergestallt ginn, och déi rezent Ëmsetzung an de leschten Versioune vun LXD vun der Ënnerstëtzung fir QEMU virtuelle Maschinnen parallel mat Container. Amplaz léiere mir just d'Basis vun der Containerverwaltung - Astelle vu Späicherpools, Vernetzung, Lafen e Container, Uwendung vun Ressourcelimiten a wéi Dir Schnappschëss benotzt, fir datt Dir e Basisverständnis vu LXD kritt a Container op Linux benotzt.

Fir komplett Informatioun, kuckt w.e.g. op déi offiziell Quell:

Navigatioun

Installatioun LXD ^

LXD op Ubuntu Verdeelungen installéieren ^

Am Ubuntu 19.10 Verdeelungspaket lxd huet eng Emissioun op snap Package:

apt search lxd

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

Dëst bedeit datt zwee Packagen gläichzäiteg installéiert ginn, een als System Package an deen aneren als Snap Package. D'Installatioun vun zwee Packagen op engem System kann e Problem erstellen wou de System Package verwaist ka ginn wann de Snap Package vum Snap Package Manager ewechgeholl gëtt.

Fannt Pak lxd am Snap Repository kënnt Dir de folgende Kommando benotzen:

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

Andeems Dir de Kommando ausféiert list Dir kënnt sécherstellen, datt de Pak lxd nach net installéiert:

snap list

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

Trotz der Tatsaach datt LXD e Snap Package ass, muss et duerch de System Package installéiert ginn lxd, déi déi entspriechend Grupp am System erstellen, déi néideg Utilities an /usr/bin an esou weider.

sudo apt update
sudo apt install lxd

Loosst eis sécher sinn datt de Package als Snap Package installéiert ass:

snap list

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

LXD op Arch Linux Verdeelungen installéieren ^

Fir de LXD Package op de System z'installéieren, musst Dir déi folgend Kommandoen ausféieren, déi éischt wäert d'Lëscht vun de Packagen um System aktualiséieren, déi am Repository verfügbar sinn, déi zweet wäert de Package direkt installéieren:

sudo pacman -Syyu && sudo pacman -S lxd

Nodeems Dir de Package installéiert hutt, fir LXD vun engem normale Benotzer ze verwalten, muss et an de Systemgrupp bäigefüügt ginn lxd:

sudo usermod -a -G lxd user1

Loosst eis sécher de Benotzer user1 zu Grupp dobäi lxd:

id -Gn user1

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

Wann de Grupp lxd ass net an der Lëscht ze gesinn, da musst Dir d'Benotzersessioun erëm aktivéieren. Fir dëst ze maachen, musst Dir Iech ënner dem selwechte Benotzer ausloggen an aloggen.

Aktivéieren an systemd Luede de LXD Service beim Systemstart:

sudo systemctl enable lxd

Loosst eis de Service starten:

sudo systemctl start lxd

Iwwerpréift de Servicestatus:

sudo systemctl status lxd

Storage LXD (Storage) ^

Ier d'Initialiséierung ufänkt, musse mir verstoen wéi d'Lagerung am LXD logesch arrangéiert ass.

Lagerung (Stockage) besteet aus vun engem oder méi Stockage Pool déi ee vun den ënnerstëtzten Dateisystemer wéi ZFS, BTRFS, LVM oder reguläre Verzeichnisser benotzt. All Stockage Pool ass a Bänn opgedeelt (Stockage Volumen) déi Biller, Container oder Daten fir aner Zwecker enthalen.

  • Biller - Dëst si speziell zesummegesate Verdeelungen ouni de Linux Kernel a verfügbar vun externe Quellen
  • Container - dës sinn ofgesat Verdeelunge vu Biller, prett fir ze benotzen
  • Snapshots - dëst sinn Schnappschëss vum Zoustand vun de Container, op déi Dir zréck kënnt

Basis Features vun LXD - Linux Container Systemer

Fir d'Lagerung am LXD ze verwalten, benotzt de Kommando lxc storage e Certificat fir deen Dir kritt andeems Dir de Schlëssel spezifizéiert - lxc storage --help

De folgende Kommando weist eng Lëscht vun all Stockage Pool an LXD Stockage:

lxc storage list

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

Fir eng Lëscht vun all ze gesinn Stockage Volumen an der gewielter Stockage Pool déngt d'Equipe 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       |
+-----------+----------------------------------+-------------+---------+

Och wann fir Stockage Pool Wann Dir erstellt, gouf de BTRFS Dateisystem ausgewielt, kritt dann eng Lëscht Stockage Volumen oder Ënnervolumen an der BTRFS Interpretatioun kënnt Dir den Toolkit vun dësem Dateiesystem benotzen:

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

LXD initialiséieren ^

Ier Dir Container erstellt a benotzt, musst Dir eng allgemeng LXD Initialiséierung ausféieren, déi d'Netzwierk a Späichere erstellt a konfiguréiert. Dëst kann manuell mat Standard Client Kommandoen gemaach ginn, déi an der Lëscht verfügbar sinn, andeems Dir de Kommando rufft lxc --help oder benotzt den Initialiséierungsassistent lxd init Äntwert op e puer Froen.

Wielt e Dateiesystem fir Storage Pool ^

Wärend der Initialiséierung stellt LXD verschidde Froen, ënner anerem d'Bestëmmung vum Dateisystemtyp fir de Standard Stockage Pool. Par défaut gëtt de BTRFS Dateisystem dofir ausgewielt. Et wäert onméiglech sinn op eng aner FS z'änneren no der Schafung. Fir e FS ze wielen gëtt et proposéiert Fonktioun Verglach Dësch:

Fonktioun
Guide
Btrfs
LVM
ZFS
CEPH

Optimiséiert Bildlagerung
nee
jo
jo
jo
jo

Optimiséiert Instanz Kreatioun
nee
jo
jo
jo
jo

Optimiséiert Snapshot Kreatioun
nee
jo
jo
jo
jo

Optimiséiert Bildtransfer
nee
jo
nee
jo
jo

Optimiséiert Instanz Transfert
nee
jo
nee
jo
jo

kopéieren op schreiwen
nee
jo
jo
jo
jo

Block baséiert
nee
nee
jo
nee
jo

Direkt Klonen
nee
jo
jo
jo
jo

Stockage Chauffer benotzbar an engem Container
jo
jo
nee
nee
nee

Restauréieren vun eelere Schnappschëss (net lescht)
jo
jo
jo
nee
jo

Stockage Quoten
Jo(*)
jo
jo
jo
nee

Initialiséiere vum Netzwierk an de Späicherpool mam Wizard ^

De nächste Kommando, dee mir kucken, proposéiert d'Haaptkomponente vum LXD opzestellen andeems Dir einfach Froen beäntwert mam Initialiséierungsassistent.

Kommando lafen lxc init a gitt d'Äntwerten op d'Froen nom Doppelpunkt wéi am Beispill hei ënnendrënner oder ännert se no Äre Bedéngungen:

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]:

En zousätzleche Späicherpool erstellen ^

Am virege Schrëtt hu mir erstallt Stockage Pool deen den Numm krut ssdpool an d'Datei vun deem ass op mengem System op /var/lib/lxd/disks/ssdpool.img. Dës Dateisystemadress entsprécht dem kierperlechen SSD Drive a mengem PC.

Déi folgend Aktiounen, fir d'Verständnis vun der Roll auszebauen Stockage Pool am Repository wäerte mir en zweeten erstellen Stockage Pool déi kierperlech op enger anerer Zort Disk, HDD, läit. De Problem ass datt LXD Iech net erlaabt ze kreéieren Stockage Pool aus Adress /var/lib/lxd/disks/ an och symbolesch Linken funktionnéieren net, gesinn d'Äntwert vum Entwéckler. Mir kënnen dës Begrenzung während der Initialiséierung / Formatéierung ëmgoen Stockage Pool andeems Dir de Wäert als Blockapparat spezifizéieren anstatt de Wee zu der Loopback-Datei andeems Dir dëst am Schlëssel spezifizéiert source.

Also, virun der Schafung Stockage Pool Dir musst eng Loopback-Datei oder eng existent Partition op Ärem Dateiesystem definéieren, déi se benotzt. Fir dëst ze maachen, wäerte mir eng Datei erstellen a benotzen déi mir an der Gréisst op 10GB limitéieren:

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

Loosst eis d'Loopback-Datei mat engem gratis Loopback-Apparat verbannen:

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

/dev/loop1

Dank dem Schlëssel --show de Kommando ausféieren gëtt den Numm vum Apparat zréck op den Ecran, an deem eis Loopback-Datei verbonnen ass. Wann néideg, kënne mir eng Lëscht vun all beschäftegten Apparater vun dësem Typ weisen fir sécherzestellen datt eis Handlungen richteg sinn:

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

Vun der Lëscht kënnt Dir feststellen datt den Apparat huet /dev/loop1 loopback Datei abegraff /mnt/work/lxd/hddpool.img, an am Apparat /dev/loop0 loopback Datei abegraff /var/lib/lxd/disks/ssdpool.img déi dem Default entsprécht Stockage Pool.

De folgende Kommando erstellt en neien Stockage Pool an LXD baséiert op der Loopback Datei déi mir just virbereet hunn. LXD wäert d'Loopback Datei formatéieren /mnt/work/lxd/hddpool.img am Apparat /dev/loop1 fir de BTRFS Dateisystem:

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

Loosst eis eng Lëscht vun allem weisen Stockage Pool op Écran:

lxc storage list

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

D'Erhéijung vun der Storage Pool Gréisst ^

No der Schafung Stockage Pool, wann néideg, kann et erweidert ginn. Fir Stockage Pool baséiert op dem BTRFS Dateisystem, lafen déi folgend Kommandoen:

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 Insertion vun enger Loopback Datei an engem Loopback Apparat Slot ^

Mir hunn e klenge Problem, wann Dir de Hostsystem nei starten, d'Datei /mnt/work/lxd/hddpool.img wäert "fléien" aus dem Apparat /dev/loop1 an de LXD-Service klappt beim Luede well et net an dësem Apparat gesäit. Fir dëse Problem ze léisen, musst Dir e Systemservice erstellen deen dës Datei an den Apparat setzt /dev/loop1 wann de Hostsystem boot.

Loosst eis schafen Apparat Dateityp Service в /etc/systemd/system/ fir de SystemD Initialiséierungssystem:

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

Aktivéiert de Service:

sudo systemctl enable lxd-hddpool

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

Nodeems de Hostsystem nei gestart gouf, kontrolléiere mir de Servicestatus:

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).

Vun der Ausgab kënne mir verifizéieren datt de Servicezoustand ass aktiv, trotz der Tatsaach datt d'Ausféierung vun eisem Skript vun engem Kommando fäerdeg war, huet d'Optioun eis erlaabt dëst ze maachen RemainAfterExit=true.

Sécherheet. Container Privilegien ^

Well all Containerprozesser tatsächlech isoléiert am Hostsystem lafen mat sengem Kernel, fir den Zougang vu Containerprozesser zum Hostsystem weider ze schützen, bitt LXD Prozessprivileg, wou:

  • Privilegéiert Container - dëst sinn Container an deenen Prozesser mat UID a GID dem selwechte Besëtzer entspriechen wéi am Hostsystem. Zum Beispill, e Prozess, deen an engem Container mat enger UID vun 0 leeft, huet all déiselwecht Zougangsrechter wéi e Prozess am Hostsystem mat enger UID vun 0. An anere Wierder, de Root Benotzer am Container huet all d'Rechter net nëmmen an de Container, awer och um Hostsystem, wann hien ausserhalb vum isoléierten Nummraum vum Container ka goen.

  • Onprivilegéiert Container - dëst sinn Container, an deenen d'Prozesser dem Besëtzer vun der UID a GID mat enger Nummer vun 0 bis 65535 gehéieren, awer fir den Hostsystem gëtt de Besëtzer maskéiert mat derbäigesate SubUID an SubGID Bits, respektiv. Zum Beispill gëtt e Benotzer mat UID = 0 an engem Container um Hostsystem als SubUID + UID. Dëst schützt den Hostsystem well wann all Prozess am Container fäeg ass säin isoléierten Nummraum z'entkommen, kann et nëmme mam Hostsystem kommunizéieren als Prozess mat engem onbekannte, ganz héije UID / GID.

Par défaut hunn nei erstallt Container en onprivilegéierte Status an dofir musse mir e SubUID an SubGID definéieren.

Loosst eis zwee Konfiguratiounsdateien erstellen, an deenen mir d'Mask fir SubUID a SubGID setzen, respektiv:

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

Fir d'Ännerungen ëmzesetzen, muss de LXD Service nei gestart ginn:

sudo systemctl restart lxd

Erstellt e virtuellen Netzwierkschalter ^

Well mir virdru d'Netzwierk initialiséiert hunn mam Initialiséierungsassistent lxd init an erstallt en Netzwierkapparat lxdbr0, da wäerte mir an dëser Rubrik einfach mat Vernetzung am LXD kennen léieren a wéi een e virtuelle Schalter (Bréck) mam Client Kommando erstellt.

Déi folgend Diagramm weist wéi e Schalter (Bréck) den Host a Container an en Netz verbënnt:

Basis Features vun LXD - Linux Container Systemer

Container kënnen iwwer e Netzwierk mat anere Container oder dem Host kommunizéieren, op deem dës Container zerwéiert ginn. Fir dëst ze maachen, musst Dir déi virtuell Netzwierkkaarte vun de Container mat engem virtuelle Schalter verbannen. Mir erstellen als éischt e Schalter, an d'Netzwierkschnëttplazen vum Container ginn an de folgende Kapitele verlinkt, nodeems de Container selwer erstallt gouf.

De folgende Kommando erstellt e Schalter mat engem Subnet 10.0.5.0/24 an IPv4 Adress 10.0.5.1/24, an enthält och ipv4.nat sou datt d'Container Zougang zum Internet iwwer den Host mam NAT Service benotzen:

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

Iwwerpréift d'Lëscht vun Netzwierkapparater verfügbar am LXD:

lxc network list

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

Dir kënnt och verifizéieren datt en Netzwierkapparat erstallt gouf mat dem Standardtool vun der Linux Verdeelung - ip link oder 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

Configuratioun Profil ^

All Container an LXD huet seng eege Configuratioun a kann et mat global deklaréiert Configuratioun genannt verlängeren Configuratioun Profiler. Konfiguratiounsprofile op e Container applizéieren huet e Kaskademodell, dat folgend Beispill weist dat:

Basis Features vun LXD - Linux Container Systemer

An dësem Beispill sinn dräi Profiler am LXD System erstallt: default, hddpool и hostfs. All dräi Profiler ginn op e Container applizéiert deen eng lokal Konfiguratioun huet (gro Gebitt). Profil default huet en Apparat root déi e Parameter huet pool ass gläich ssdpool, mee merci fir d'Kaskadekonfiguratioun Applikatioun Modell, kënne mir e Profil op de Container gëllen hddpool déi e Parameter huet pool wäert de selwechte Parameter vum Profil iwwerschreiden default an de Container kritt d'Apparatkonfiguratioun root mat Parameter pool selwecht as hddpool, an de Profil hostfs füügt einfach en neien Apparat un de Container.

Fir d'Lëscht vun verfügbare Konfiguratiounsprofiler ze gesinn, benotzt de folgende Kommando:

lxc profile list

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

Eng komplett Lëscht vun verfügbare Kommandoen fir mat engem Profil ze schaffen kann kritt ginn andeems Dir de Schlëssel bäidréit --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

Änneren Äre Profil ^

Default Configuratioun Profil default huet keng Netzwierkkaart Konfiguratioun fir de Container an all nei erstallt Container hunn keen Netz, fir si ass et néideg lokal (dedizéierten) Netzwierkapparater mat engem separaten Kommando ze kreéieren, awer mir kënnen e globalen Netzwierkapparat an der Konfiguratioun erstellen Profil deen tëscht all Container mat dësem Profil gedeelt gëtt. Op dës Manéier, direkt nom Kommando fir en neie Container ze kreéieren, hunn se e Netzwierk mat Netzzougang. Zur selwechter Zäit ginn et keng Restriktiounen; mir kënnen ëmmer e lokalen Netzwierkapparat spéider erstellen wann néideg.

De folgende Kommando wäert den Apparat an de Konfiguratiounsprofil addéieren eth0 Zort nic un d'Netz verbonnen lxdbr0:

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

Et ass wichteg ze bemierken datt well mir den Apparat tatsächlech an de Konfiguratiounsprofil bäigefüügt hunn, wa mir eng statesch IP Adress am Apparat spezifizéiert hunn, dann all Container déi dëse Profil benotzen déi selwecht IP Adress deelen. Wann et e Besoin ass fir e Container mat enger statescher IP Adress ze kreéieren déi fir de Container zougewisen ass, da sollt Dir eng Netzwierkgerätskonfiguratioun um Containerniveau (lokal Konfiguratioun) mam IP Adressparameter erstellen, an net um Profilniveau.

Loosst eis de Profil kucken:

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: []

An dësem Profil kënne mir gesinn datt fir all nei erstallt Container zwee Apparater erstallt ginn:

  • eth0 - Apparat Typ nic verbonne mat engem Schalter (Netzbréck) lxdbr0
  • root - Apparat Typ disk déi benotzt engem Stockage Pool ssdpool

Schafen nei Profiler ^

Fir virdrun erstallt ze benotzen Stockage Pool Container, e Konfiguratiounsprofil erstellen ssdroot an deem mir en Apparat wéi disk mat Montéierung Punkt / (root) benotzt déi virdru erstallt Stockage Pool - ssdpool:

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

Ähnlech erstellen mir en Apparat wéi disk, mee an dësem Fall benotzt Stockage Pool - hddpool:

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

Konfiguratiounsprofile kontrolléieren:

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: []

Image Repository ^

Container ginn aus Biller erstallt déi speziell versammelt Verdeelunge sinn déi kee Linux Kernel hunn. Dofir, ier de Container leeft, muss en aus dësem Bild ofgesat ginn. D'Quell vun de Biller ass e lokale Repository an deem Biller vun externe Repositories erofgeluede ginn.

Remote Image Repositories ^

Par défaut ass LXD konfiguréiert fir Biller vun dräi Fernquellen ze kréien:

  • ubuntu: (fir stabil Ubuntu Biller)
  • ubuntu-deeglech: (fir deeglech Ubuntu Biller)
  • Biller: (fir eng Rëtsch aner 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    |
+-----------------+------------------------------------------+--------+--------+

Zum Beispill, Repository ubuntu: huet déi folgend Biller:

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  |
+----------------------------------------------+--------------+----------+------------+

Fir eng limitéiert Zuel vu Kolonnen ze weisen, hu mir d'Optioun benotzt -c mat Parameteren dasut, a limitéiert och d'Längt vun der Lëscht mam Kommando head.

Filteren ass verfügbar fir eng Lëscht vu Biller ze weisen. De folgende Kommando wäert all verfügbare Verdeelungsarchitekturen oplëschten 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        |
+------------------------------+--------------------------------------+--------------+

Lokal Bild Repository ^

Fir de Container ze benotzen, musst Dir e Bild vum globalen Repository op de lokale addéieren local:. Elo ass de lokale Repository eidel, de Kommando suergt dofir lxc image list. Wann d'Method list spezifizéiere kee Repository, da gëtt de lokale Repository als Standard benotzt - local:

lxc image list local:

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

Biller am Repository gi mat de folgende Methoden geréiert:

Equipe
Beschreiwung

lxc Bild alias
Managen Bild Aliasen

lxc Bild Kopie
Kopie Biller tëscht Serveren

lxc Bild läschen
Läscht Biller

lxc Bild edit
Bildeigenschaften änneren

lxc Bild exportéieren
Export an download Biller

lxc Bild Import
Importéiert Biller an de Bildgeschäft

lxc Bild Infoen
Show nëtzlech Informatioun iwwer Biller

lxc Bild Lëscht
Lëscht Biller

lxc Bild Update
Biller erfrëschen

lxc Bild weisen
Show Bild Eegeschaften

Kopéiert d'Bild an de lokale Repository vum globalen images::

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

Image copied successfully!

Loosst eis eng Lëscht vun all de Biller déi aktuell am lokalen Repository verfügbar sinn local::

lxc image -c lfdatsu list local:

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

LXD Configuratioun ^

Zousätzlech zum interaktiven Modus ënnerstëtzt LXD och en net-interaktiven Konfiguratiounsinstallatiounsmodus, dëst ass wann d'Konfiguratioun a Form vun enger YAML-Datei spezifizéiert gëtt, e spezielle Format dat Iech erlaabt d'ganz Konfiguratioun gläichzäiteg z'installéieren, d'Ausféierung ëmgoen vu villen interaktiven Kommandoen déi uewen an dësem Artikel diskutéiert goufen, dorënner Netzwierkkonfiguratioun, Schafung vu Konfiguratiounsprofiler, etc. Mir wäerten dëst Gebitt net hei ofdecken, Dir kënnt et eleng kucken. an der Dokumentatioun.

Nächst interaktiv Kommando lxc config déi mir kucken erlaabt Iech d'Konfiguratioun ze setzen. Zum Beispill, fir sécherzestellen datt erofgeluede Biller an de lokale Repository net automatesch vun de globalen Repositories aktualiséiert ginn, kënne mir dëst Verhalen mat dem folgenden Kommando aktivéieren:

lxc config set images.auto_update_cached=false

Erstellt a verwalten e Container ^

Fir e Container ze kreéieren benotzt de Kommando lxc init op déi Wäerter iwwerginn репозиторий:образ an dann déi gewënscht ID fir de Container. De Repository kann als lokal spezifizéiert ginn local: sou ass all global. Wann de Repository net spezifizéiert ass, da gëtt Par défaut de lokale Repository benotzt fir no dem Bild ze sichen. Wann d'Bild aus dem globale Repository spezifizéiert gëtt, da gëtt d'Bild fir d'éischt an de lokale Repository erofgelueden an duerno benotzt fir de Container ze kreéieren.

Loosst eis de folgende Kommando ausféieren fir eisen éischte Container ze kreéieren:

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

Loosst eis d'Kommandoschlësselen kucken, déi mir hei an Uerdnung benotzen:

  • alpine3 - En Alias ​​(Alias) gëtt fir d'Bild spezifizéiert dat virdru an de lokale Repository eropgeluede gouf. Wann den Alias ​​net fir dëst Bild erstallt gouf, da kënnt Dir ëmmer op d'Bild bezéien Fangerofdréck déi an der Tabell ugewise gëtt.
  • alp - Setzt den Identifizéierer fir de Container
  • --storage - Dëse Schlëssel weist an deem Stockage Pool e Container gëtt erstallt
  • --profile - Dës Schlësselkaskade gëllen Konfiguratioun vu virdru erstallte Konfiguratiounsprofiler op de Container

Mir starten de Container, deen ufänkt den Init System vun der Verdeelung ze starten:

lxc start alp

Dir kënnt och de Kommando benotzen lxc launch wat Iech erlaabt Teams ze kombinéieren lxc init и lxc start an enger Operatioun.

Den Zoustand vum Container kontrolléieren:

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

Iwwerpréift vun der Containerkonfiguratioun:

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: ""

An der Rubrik profiles mir kënne sécherstellen datt dësen Container zwee Konfiguratiounsprofile benotzt - default и hddroot. An der Rubrik devices mir kënnen nëmmen een Apparat z'entdecken well de Reseau Apparat um Profil Niveau geschaf gouf default. Fir all Apparater ze gesinn, déi vum Container benotzt ginn, musst Dir e Schlëssel derbäisetzen --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: ""

Eng statesch IP Adress setzen ^

Wa mir probéieren eng IP Adress fir en Netzwierkapparat ze setzen eth0 Equipe lxc config device set alp geduecht fir d'Container Configuratioun, da kréie mir e Feeler deen mellt datt den Apparat net existéiert well den Apparat eth0 déi vum Container benotzt gëtt gehéiert zum Profil default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Mir kënnen natierlech eng statesch IP Adress fir eth0 Apparater am Profil, awer et wäert d'selwecht sinn fir all Container déi dëse Profil benotzen. Dofir, loosst eis en Apparat addéieren deen dem Container gewidmet ass:

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

Da musst Dir de Container nei starten:

lxc restart alp

Wa mir elo d'Containerkonfiguratioun kucken, brauche mir d'Optioun net ze benotzen --expanded fir den Netzwierkapparat ze gesinn eth0, well mir et um Containerniveau erstallt hunn an et iwwer deeselwechten Apparat aus dem Profil kaskadéiert huet 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: ""

E Container ewechhuelen ^

Fir e Container ze läschen, benotzt de Kommando lxc delete, awer ier de Container ewechgeholl gëtt, muss et mat dem Kommando gestoppt ginn lxc stop:

lxc stop alp

lxc list

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

Nodeems mir iwwerpréift hunn datt den Zoustand vum Container ginn ass STOPPEN, et kann ewechgeholl ginn Stockage Pool:

lxc delete alp

Container Zougang ^

Fir Kommandoen an engem Container direkt auszeféieren, Netzwierkverbindungen ëmzegoen, benotzt de Kommando lxc exec déi Kommandoen am Container ausféiert ouni d'System Shell ze starten. Wann Dir e Kommando an enger Shell muss ausféieren mat Shellmuster wéi Variablen, Dateiviruleedungen (Päif), etc., da musst Dir d'Shell explizit starten an de Kommando als Schlëssel passéieren, zum Beispill:

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

De Kommando benotzt e spezielle Flucht Charakter fir speziell Charakter $ sou datt d'Variabel $HOME gouf net op der Hostmaschinn interpretéiert, awer nëmmen am Container interpretéiert.

Et ass och méiglech den interaktiven Shell-Modus unzefänken, an dann d'Sessioun ofzeschléissen andeems Dir Hotkey ausféiert CTRL+D:

lxc exec alp -- /bin/sh

Container Ressource Gestioun ^

Am LXD kënnt Dir Containerressourcen verwalten mat engem spezielle Set vu Konfiguratioun. Eng komplett Lëscht vun Container Configuratioun Parameteren kann fonnt ginn an der Dokumentatioun.

RAM Ressource Limitatioun ^

Parameter limits.memory limitéiert d'Quantitéit vum RAM verfügbar fir de Container. De Wäert ass eng Zuel an ee vun verfügbare Suffixen.

Loosst eis d'RAM Limit vum Container op 256 MB setzen:

lxc config set alp limits.memory 256MB

Och ginn et aner Parameteren fir d'Erënnerung ze limitéieren:

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

Equipe lxc config show erlaabt Iech déi ganz Containerkonfiguratioun ze weisen, inklusiv déi ugewandte Ressourcelimit déi agestallt gouf:

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 Ressource Limite ^

Et gi verschidde Weeër fir CPU Ressourcen ze limitéieren. Zorte vu Restriktiounen:

  • limit.cpu - bindt e Container un een oder méi CPU-Kären
  • limits.cpu.allowance - geréiert entweder CFS Scheduler Quoten wann d'Zäitlimit passéiert ass, oder den universellen CPU Ressource Sharing Mechanismus wann de Prozentsaz passéiert ass
  • limits.cpu.priority - Scheduler Prioritéit wann verschidde Instanzen déi e Set vu Prozessoren deelen deeselwechte Prozentsaz vu Prozessoren zougewisen hunn

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: ""

Disk Space Limitatioun ^

Zousätzlech zu Restriktiounen wéi limits.read, limits.write mir kënnen och d'Quantitéit vum Disk Space limitéieren, dee vum Container verbraucht gëtt (schafft nëmme mat ZFS oder BTRFS):

lxc config device set alp root size=2GB

No der Installatioun, am Parameter devices.root.size Mir kënnen déi gesat Limit verifizéieren:

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

Fir déi benotzte Disk Quoten ze gesinn, kënne mir vum Kommando kréien 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

Trotz der Tatsaach, datt mir eng Limite fir de Root-Apparat vum Container op 2GB gesat hunn, System Utilities wéi z. df wäert dës Restriktioun net gesinn. Fir dëst ze maachen, wäerte mir e klengen Test maachen an erausfannen wéi et funktionnéiert.

Loosst eis 2 nei identesch Container am selwechten erstellen Stockage 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         |
+------+---------+------------------+------+-----------+-----------+

Loosst eis eng 1GB Datei an engem vun de Container erstellen:

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

Loosst eis sécher sinn datt d'Datei erstallt gëtt:

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

Wa mir am zweeten Container kucken, kontrolléiert d'Existenz vun enger Datei op der selwechter Plaz, da wäert dës Datei net do sinn, wat erwaart gëtt, well Container an hirem eegenen erstallt ginn Stockage Volumen am selwechten Stockage Pool:

lxc exec alp2 -- ls -lh
total 0

Awer loosst eis d'Wäerter vergläichen déi et produzéiert df op engem an deem aneren Container:

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% /
...

Gerät /dev/loop1 montéiert wéi d'Root-Partition ass Stockage Pool déi dës Container benotzen, sou datt se säi Volumen tëscht zwee deelen.

Ressource Konsum Statistiken ^

Dir kënnt Ressourceverbrauchstatistike fir e Container kucken andeems Dir de Kommando benotzt:

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

Schafft mat Snapshots ^

LXD huet d'Fäegkeet Snapshots ze kreéieren an de Containerzoustand vun hinnen ze restauréieren.

Fir e Snapshot ze kreéieren, fuert de folgende Kommando:

lxc snapshot alp snapshot1

D'Equipe lxc snapshot kee Schlëssel verfügbar listDofir, fir d'Lëscht vun de Schnappschëss ze gesinn, musst Dir de Kommando benotzen deen allgemeng Informatioun iwwer de Container weist:

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

Dir kënnt e Container aus engem Snapshot mat dem Kommando restauréieren lxc restore de Container spezifizéiert fir deen d'Restauratioun duerchgefouert gëtt an de Snapshot Alias:

lxc restore alp snapshot1

De folgende Kommando gëtt benotzt fir e Snapshot ze läschen. Notéiert w.e.g. datt d'Kommando-Syntax net wéi all aner ähnlech ass; hei musst Dir e Forward-Slash nom Containernumm uginn. Wann d'Schrëtt ewechgelooss gëtt, da gëtt de Kommando fir e Snapshot ze läschen als Kommando interpretéiert fir e Container ze läschen!

lxc delete alp/snapshot1

Am Beispill hei uewen hu mir sougenannte stateless Schnappschëss gekuckt. LXD huet eng aner Aart vu Schnappschëss - stateful, déi den aktuellen Zoustand vun alle Prozesser am Container späichert. Et ginn eng Rei vun interessanten an nëtzlechen Fonctiounen verbonne mat stateful Snapshots.

Wat soss? ^

  • E Modul ass verfügbar fir Python Entwéckler PyLXD déi eng API zu LXD ubitt

UPDATE 10.04.2020/15/00 XNUMX:XNUMX: Navigatioun dobäigesat

Source: will.com

Setzt e Commentaire