LXD is de systeemcontainermanager van de volgende generatie, zo staat er bron. Het biedt een gebruikersinterface die lijkt op virtuele machines, maar gebruikt in plaats daarvan Linux-containers.

LXD-kern is een bevoorrechte daemon (een service die draait met rootrechten) die een REST API levert via een lokale Unix-socket, maar ook via het netwerk als de juiste configuratie is geïnstalleerd. Klanten, zoals de opdrachtregeltool die bij LXD wordt geleverd, dienen aanvragen in via deze REST API. Dit betekent dat, of u nu toegang heeft tot een lokale host of een externe host, alles hetzelfde werkt.

In dit artikel zullen we niet in detail ingaan op de concepten van LXD, we zullen niet alle beschikbare mogelijkheden beschouwen die in de documentatie worden beschreven, inclusief de recente implementatie in de nieuwste versies van LXD van ondersteuning voor QEMU virtuele machines parallel met containers. In plaats daarvan leren we alleen de basisprincipes van containerbeheer: het opzetten van opslagpools, netwerken, het runnen van een container, het toepassen van resourcelimieten en het gebruik van snapshots, zodat je een basiskennis krijgt van LXD en containers op Linux kunt gebruiken.

Voor volledige informatie verwijzen wij u naar de officiële bron:

• Website van ontwikkelaar
• Документация
• forum

Navigatie

• Installatie LXD
  • LXD installeren op Ubuntu-distributies
  • LXD installeren op Arch Linux-distributies
• Opslag LXD (opslag)
• LXD initialiseren
  • Een bestandssysteem voor de opslagpool selecteren
  • Het netwerk en de opslagpool initialiseren met behulp van de wizard
  • Een extra opslagpool creëren
    • De grootte van de opslagpool vergroten
    • Automatische invoeging van een loopback-bestand in een loopback-apparaatsleuf
  • Veiligheid. Containerrechten
  • Een virtuele netwerkswitch maken
  • Configuratieprofiel
    • Je profiel bewerken
    • Nieuwe profielen aanmaken
  • Beeldopslagplaats
    • Externe beeldopslagplaatsen
    • Lokale beeldopslagplaats
  • LXD-configuratie
• Een container maken en beheren
  • Een statisch IP-adres instellen
  • Een container verwijderen
  • Toegang tot containers
  • Beheer van containerresources
    • Beperking van RAM-bronnen
    • CPU-bronlimiet
    • Beperking van schijfruimte
    • Statistieken over het verbruik van hulpbronnen
  • Werken met momentopnamen

Installatie LXD ^

LXD installeren op Ubuntu-distributies ^

In het Ubuntu 19.10-distributiepakket lxd heeft een uitzending snap-pakket:

apt search lxd

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

Dit betekent dat er twee pakketten tegelijk worden geïnstalleerd, één als systeempakket en het andere als snappakket. Het installeren van twee pakketten op een systeem kan een probleem veroorzaken waarbij het systeempakket verweesd kan raken als het snap-pakket wordt verwijderd door de snap-pakketbeheerder.

Zoek pakket lxd in de snap repository kun je de volgende opdracht gebruiken:

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

Door het commando uit te voeren list U kunt ervoor zorgen dat het pakket lxd nog niet geïnstalleerd:

snap list

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

Ondanks het feit dat LXD een snappakket is, moet het via het systeempakket worden geïnstalleerd lxd, waarmee de overeenkomstige groep in het systeem wordt aangemaakt, waarin de benodigde hulpprogramma's worden geplaatst /usr/bin etc.

sudo apt update
sudo apt install lxd

Laten we ervoor zorgen dat het pakket als een snappakket wordt geïnstalleerd:

snap list

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

LXD installeren op Arch Linux-distributies ^

Om het LXD-pakket op het systeem te installeren, moet u de volgende opdrachten uitvoeren. De eerste zal de lijst met pakketten op het systeem bijwerken die beschikbaar zijn in de repository, de tweede zal het pakket direct installeren:

sudo pacman -Syyu && sudo pacman -S lxd

Na installatie van het pakket moet het aan de systeemgroep worden toegevoegd om LXD door een gewone gebruiker te kunnen beheren lxd:

sudo usermod -a -G lxd user1

Laten we ervoor zorgen dat de gebruiker user1 toegevoegd aan groep lxd:

id -Gn user1

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

Als de groep lxd niet zichtbaar is in de lijst, dan moet u de gebruikerssessie opnieuw activeren. Hiervoor moet u uitloggen en inloggen onder dezelfde gebruiker.

Activeer binnen systemd het laden van de LXD-service bij het opstarten van het systeem:

sudo systemctl enable lxd

Laten we de dienst starten:

sudo systemctl start lxd

De servicestatus controleren:

sudo systemctl status lxd

Opslag LXD (opslag) ^

Voordat de initialisatie begint, moeten we begrijpen hoe de opslag in LXD logisch is ingedeeld.

Opslag (Opbergen) bestaat uit van één of meerdere Opslagpool die een van de ondersteunde bestandssystemen gebruikt, zoals ZFS, BTRFS, LVM of gewone mappen. Elk Opslagpool is verdeeld in volumes (Opslagvolume) die afbeeldingen, containers of gegevens voor andere doeleinden bevatten.

• beeldspraak - dit zijn speciaal samengestelde distributies zonder de Linux-kernel en beschikbaar via externe bronnen
• containers - dit zijn ingezette distributies vanaf afbeeldingen, klaar voor gebruik
• Momentopnamen - dit zijn momentopnamen van de staat van containers waar u naar terug kunt keren

Gebruik de opdracht om de opslag in LXD te beheren lxc storage een certificaat waarvoor u kunt verkrijgen door de sleutel op te geven - lxc storage --help

Met de volgende opdracht wordt een lijst met alle weergegeven Opslagpool in LXD-opslag:

lxc storage list

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

Om een ​​lijst van allemaal te bekijken Opslagvolume in de geselecteerde Opslagpool bedient het 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       |
+-----------+----------------------------------+-------------+---------+

Ook als voor Opslagpool Bij het maken werd het BTRFS-bestandssysteem geselecteerd en kreeg vervolgens een lijst Opslagvolume of deelvolumes in de BTRFS-interpretatie kunt u de toolkit van dit bestandssysteem gebruiken:

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 initialiseren ^

Voordat u containers maakt en gebruikt, moet u een algemene LXD-initialisatie uitvoeren waarmee het netwerk en de opslag worden gemaakt en geconfigureerd. Dit kan handmatig worden gedaan met behulp van standaard clientopdrachten die beschikbaar zijn in de lijst door de opdracht aan te roepen lxc --help of met behulp van de initialisatiewizard lxd init een paar vragen beantwoorden.

Een bestandssysteem voor de opslagpool selecteren ^

Tijdens de initialisatie stelt LXD verschillende vragen, waaronder het bepalen van het standaardbestandssysteemtype Opslagpool. Standaard is hiervoor het BTRFS-bestandssysteem geselecteerd. Het zal onmogelijk zijn om na de creatie naar een ander FS te veranderen. Er wordt voorgesteld om een ​​FS te selecteren functievergelijkingstabel:

Kenmerk
Directory
Btrfs
LVM
ZFS
CEPH

Geoptimaliseerde beeldopslag
geen
ja
ja
ja
ja

Geoptimaliseerde creatie van instanties
geen
ja
ja
ja
ja

Geoptimaliseerde creatie van momentopnamen
geen
ja
ja
ja
ja

Geoptimaliseerde beeldoverdracht
geen
ja
geen
ja
ja

Geoptimaliseerde exemplaaroverdracht
geen
ja
geen
ja
ja

Kopiëren op schrijven
geen
ja
ja
ja
ja

Op blokken gebaseerd
geen
geen
ja
geen
ja

Direct klonen
geen
ja
ja
ja
ja

Opslagdriver bruikbaar in een container
ja
ja
geen
geen
geen

Herstellen van oudere snapshots (niet de nieuwste)
ja
ja
ja
geen
ja

Opslagquota
Ja(*)
ja
ja
ja
geen

Het netwerk en de opslagpool initialiseren met behulp van de wizard ^

De volgende opdracht die we zullen bekijken, suggereert het instellen van de belangrijkste componenten van LXD door eenvoudige vragen te beantwoorden met behulp van de initialisatiewizard.

Opdracht uitvoeren lxc init en voer de antwoorden op de vragen in na de dubbele punt, zoals weergegeven in het onderstaande voorbeeld, of wijzig ze volgens uw voorwaarden:

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

Een extra opslagpool creëren ^

In de vorige stap hebben we gemaakt Opslagpool die de naam kreeg ssdpool en waarvan het bestand zich op mijn systeem bevindt op /var/lib/lxd/disks/ssdpool.img. Dit bestandssysteemadres komt overeen met de fysieke SSD-schijf op mijn pc.

De volgende acties, om het begrip van de rol die wordt gespeeld door te vergroten Opslagpool in de repository zullen we een tweede maken Opslagpool die zich fysiek op een ander type schijf zal bevinden, HDD. Het probleem is dat LXD je niet toestaat om te creëren Opslagpool buiten adres /var/lib/lxd/disks/ en zelfs symbolische links zullen niet werken, zie de reactie van de ontwikkelaar. We kunnen deze beperking omzeilen tijdens initialisatie/formattering Opslagpool door de waarde op te geven als een blokapparaat in plaats van het pad naar het loopback-bestand door dit in de sleutel op te geven source.

Dus vóór het creëren Opslagpool u moet een loopback-bestand of een bestaande partitie op uw bestandssysteem definiëren die het zal gebruiken. Om dit te doen, zullen we een bestand maken en gebruiken dat we in grootte beperken tot 10 GB:

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

Laten we het loopback-bestand verbinden met een gratis loopback-apparaat:

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

/dev/loop1

Dankzij de sleutel --show Als u de opdracht uitvoert, keert de naam van het apparaat waarop ons loopback-bestand is aangesloten terug naar het scherm. Indien nodig kunnen we een lijst weergeven met alle drukke apparaten van dit type om er zeker van te zijn dat onze acties correct zijn:

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

Uit de lijst kunt u zien dat het apparaat dit heeft /dev/loop1 loopback-bestand inbegrepen /mnt/work/lxd/hddpool.imgen op het apparaat /dev/loop0 loopback-bestand inbegrepen /var/lib/lxd/disks/ssdpool.img wat overeenkomt met de standaard Opslagpool.

Met de volgende opdracht wordt een nieuwe gemaakt Opslagpool in LXD op basis van het loopback-bestand dat we zojuist hebben voorbereid. LXD formatteert het loopback-bestand /mnt/work/lxd/hddpool.img in het apparaat /dev/loop1 voor het BTRFS-bestandssysteem:

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

Laten we een lijst van allemaal weergeven Opslagpool screenen:

lxc storage list

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

De grootte van de opslagpool vergroten ^

Na creatie OpslagpoolIndien nodig kan het worden uitgebreid. Voor Opslagpool gebaseerd op het BTRFS-bestandssysteem, voert u de volgende opdrachten uit:

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

Automatische invoeging van een loopback-bestand in een loopback-apparaatsleuf ^

We hebben een klein probleem bij het opnieuw opstarten van het hostsysteem, het bestand /mnt/work/lxd/hddpool.img zal uit het apparaat "vliegen". /dev/loop1 en de LXD-service zal crashen tijdens het laden omdat deze deze niet op dit apparaat zal zien. Om dit probleem op te lossen, moet u een systeemservice maken die dit bestand in het apparaat plaatst /dev/loop1 wanneer het hostsysteem opstart.

Laten we creëren eenheid bestandstype service в /etc/systemd/system/ voor het SystemD-initialisatiesysteem:

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

Activeer de dienst:

sudo systemctl enable lxd-hddpool

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

Nadat we het hostsysteem opnieuw hebben opgestart, controleren we 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).

Aan de hand van de uitvoer kunnen we verifiëren dat de servicestatus is actieve, ondanks het feit dat de uitvoering van ons script vanaf één opdracht was voltooid, stelde de optie ons in staat dit te doen RemainAfterExit=true.

Veiligheid. Containerrechten ^

Omdat alle containerprocessen feitelijk geïsoleerd op het hostsysteem draaien met behulp van de kernel, biedt LXD, om de toegang van containerprocessen tot het hostsysteem verder te beschermen, procesrechten, waarbij:

• Bevoorrechte containers - dit zijn containers waarin processen met UID en GID overeenkomen met dezelfde eigenaar als op het hostsysteem. Een proces dat wordt uitgevoerd in een container met een UID van 0 heeft bijvoorbeeld dezelfde toegangsrechten als een proces op het hostsysteem met een UID van 0. Met andere woorden: de rootgebruiker in de container heeft alle rechten, niet alleen in de container, maar ook op het hostsysteem als hij buiten de geïsoleerde naamruimte van de container kan gaan.

• Onbevoorrechte containers - dit zijn containers waarin processen toebehoren aan de eigenaar van de UID en GID met een nummer van 0 tot 65535, maar voor het hostsysteem wordt de eigenaar gemaskeerd met behulp van respectievelijk de toegevoegde SubUID- en SubGID-bits. Een gebruiker met UID=0 in een container wordt bijvoorbeeld op het hostsysteem gezien als SubUID + UID. Dit beschermt het hostsysteem, omdat als een proces in de container aan zijn geïsoleerde naamruimte kan ontsnappen, het alleen met het hostsysteem kan communiceren als een proces met een onbekende, zeer hoge UID/GID.

Nieuw gemaakte containers hebben standaard een status zonder privileges en daarom moeten we een SubUID en SubGID definiëren.

Laten we twee configuratiebestanden maken waarin we het masker voor respectievelijk SubUID en SubGID instellen:

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

Om de wijzigingen toe te passen, moet de LXD-service opnieuw worden gestart:

sudo systemctl restart lxd

Een virtuele netwerkswitch maken ^

Omdat we het netwerk eerder hebben geïnitialiseerd met behulp van de initialisatiewizard lxd init en een netwerkapparaat gemaakt lxdbr0, dan zullen we in deze sectie eenvoudig kennis maken met netwerken in LXD en hoe je een virtuele switch (bridge) kunt maken met behulp van de clientopdracht.

Het volgende diagram laat zien hoe een switch (bridge) de host en containers met een netwerk verbindt:

Containers kunnen via een netwerk communiceren met andere containers of met de host waarop deze containers worden geserveerd. Hiervoor moet u de virtuele netwerkkaarten van de containers koppelen met een virtuele switch. We zullen eerst een switch maken en de netwerkinterfaces van de container zullen in de volgende hoofdstukken worden gekoppeld, nadat de container zelf is gemaakt.

Met de volgende opdracht wordt een switch met een subnet gemaakt 10.0.5.0/24 en IPv4-adres 10.0.5.1/24, en omvat ook ipv4.nat zodat containers via de host toegang kunnen krijgen tot internet met behulp van de NAT-service:

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

De lijst met netwerkapparaten controleren die beschikbaar zijn in LXD:

lxc network list

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

Je kunt ook verifiëren dat een netwerkapparaat is gemaakt met behulp van de standaardtool van de Linux-distributie - 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

Configuratieprofiel ^

Elke container in LXD heeft zijn eigen configuratie en kan deze uitbreiden met globaal gedeclareerde configuraties genaamd configuratie profielen. Het toepassen van configuratieprofielen op een container kent een cascademodel, het volgende voorbeeld laat dit zien:

In dit voorbeeld zijn er drie profielen aangemaakt in het LXD-systeem: default, hddpool и hostfs. Alle drie de profielen worden toegepast op een container met een lokale configuratie (grijs gebied). Profiel default heeft een apparaat root die een parameter heeft pool is gelijk aan ssdpool, maar dankzij het cascadeconfiguratie-applicatiemodel kunnen we een profiel op de container toepassen hddpool die een parameter heeft pool overschrijft dezelfde parameter uit het profiel default en de container ontvangt de apparaatconfiguratie root met parameters pool gelijk hddpoolen het profiel hostfs voegt eenvoudig een nieuw apparaat toe aan de container.

Gebruik de volgende opdracht om de lijst met beschikbare configuratieprofielen te bekijken:

lxc profile list

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

Een volledige lijst met beschikbare opdrachten voor het werken met een profiel kan worden verkregen door de sleutel toe te voegen --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

Je profiel bewerken ^

Standaardconfiguratieprofiel default heeft geen netwerkkaartconfiguratie voor de container en alle nieuw gemaakte containers hebben geen netwerk, daarvoor is het noodzakelijk om lokale (specifieke) netwerkapparaten te maken met een afzonderlijk commando, maar we kunnen een globaal netwerkapparaat maken in de configuratie profiel dat wordt gedeeld tussen alle containers die dit profiel gebruiken. Op deze manier beschikken ze onmiddellijk na het commando om een ​​nieuwe container aan te maken over een netwerk met netwerktoegang. Tegelijkertijd zijn er geen beperkingen; we kunnen indien nodig altijd later een lokaal netwerkapparaat maken.

Met de volgende opdracht wordt het apparaat aan het configuratieprofiel toegevoegd eth0 типа nic verbonden met het netwerk lxdbr0:

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

Het is belangrijk op te merken dat, aangezien we het apparaat daadwerkelijk aan het configuratieprofiel hebben toegevoegd, alle containers die dit profiel zullen gebruiken hetzelfde IP-adres zullen delen als we een statisch IP-adres in het apparaat specificeren. Als het nodig is om een ​​container te maken met een statisch IP-adres dat aan de container is toegewezen, moet u een netwerkapparaatconfiguratie maken op containerniveau (lokale configuratie) met de parameter IP-adres, en niet op profielniveau.

Laten we het profiel controleren:

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

In dit profiel kunnen we zien dat voor alle nieuw aangemaakte containers twee apparaten worden aangemaakt:

• eth0 - Soort apparaat nic aangesloten op een switch (netwerkbrug) lxdbr0
• root - Soort apparaat disk die gebruik maakt van een opslagpool ssdpool

Nieuwe profielen aanmaken ^

Om eerder gemaakt te gebruiken Opslagpool containers, maak een configuratieprofiel ssdroot waarin we een apparaat zoals zullen toevoegen disk met montagepunt / (root) met behulp van het eerder gemaakte Opslagpool - ssdpool:

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

Op dezelfde manier creëren we een apparaat zoals disk, maar in dit geval met behulp van Opslagpool - hddpool:

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

Configuratieprofielen controleren:

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

Beeldopslagplaats ^

Containers worden gemaakt op basis van afbeeldingen die speciaal samengestelde distributies zijn die geen Linux-kernel hebben. Voordat de container wordt uitgevoerd, moet deze daarom vanaf deze image worden geïmplementeerd. De bron van afbeeldingen is een lokale opslagplaats waarin afbeeldingen worden gedownload van externe opslagplaatsen.

Externe beeldopslagplaatsen ^

Standaard is LXD geconfigureerd om afbeeldingen van drie externe bronnen te ontvangen:

• ubuntu: (voor stabiele Ubuntu-afbeeldingen)
• ubuntu-dagelijks: (voor dagelijkse Ubuntu-afbeeldingen)
• afbeeldingen: (voor een aantal andere distributies)

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

Bijvoorbeeld een opslagplaats ubuntu: heeft de volgende afbeeldingen:

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 een ​​beperkt aantal kolommen weer te geven hebben wij gebruik gemaakt van de optie -c met parameters dasut, en beperkte ook de lengte van de lijst met de opdracht head.

Er is filtering beschikbaar om een ​​lijst met afbeeldingen weer te geven. Met de volgende opdracht worden alle beschikbare distributiearchitecturen weergegeven 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 beeldopslagplaats ^

Om de container te gaan gebruiken, moet u een afbeelding uit de globale repository aan de lokale repository toevoegen local:. Nu de lokale repository leeg is, zal het commando hiervoor zorgen lxc image list. Als de methode list specificeer geen repository, dan wordt standaard de lokale repository gebruikt - local:

lxc image list local:

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

Afbeeldingen in de repository worden beheerd met behulp van de volgende methoden:

Team
beschrijving

lxc-afbeelding alias
Beheer beeldaliassen

lxc-afbeelding kopiëren
Kopieer afbeeldingen tussen servers

lxc-afbeelding verwijderen
Verwijder afbeeldingen

lxc-afbeelding Bewerk
Afbeeldingseigenschappen bewerken

lxc-afbeelding exporteren
Afbeeldingen exporteren en downloaden

lxc-afbeelding importeren
Importeer afbeeldingen in het afbeeldingenarchief

lxc-afbeelding info
Toon nuttige informatie over afbeeldingen

lxc-afbeelding lijst
Lijst afbeeldingen

lxc-afbeelding verversen
Afbeeldingen vernieuwen

lxc-afbeelding tonen
Afbeeldingseigenschappen weergeven

Kopieer de afbeelding vanuit de globale naar de lokale repository images::

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

Image copied successfully!

Laten we een lijst weergeven met alle afbeeldingen die momenteel beschikbaar zijn in de 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-configuratie ^

Naast de interactieve modus ondersteunt LXD ook een niet-interactieve configuratie-installatiemodus, dit is wanneer de configuratie wordt gespecificeerd in de vorm van een YAML-bestand, een speciaal formaat waarmee u de volledige configuratie in één keer kunt installeren, waarbij de uitvoering wordt omzeild van de vele interactieve opdrachten die hierboven in dit artikel zijn besproken, waaronder netwerkconfiguratie, het maken van configuratieprofielen, enz. We zullen dit gebied hier niet bespreken, u kunt het zelf bekijken. bij documentatie.

Volgende interactieve opdracht lxc config waar we naar zullen kijken, stelt u in staat de configuratie in te stellen. Om er bijvoorbeeld voor te zorgen dat gedownloade afbeeldingen naar de lokale opslagplaats niet automatisch worden bijgewerkt vanuit de algemene opslagplaatsen, kunnen we dit gedrag inschakelen met de volgende opdracht:

lxc config set images.auto_update_cached=false

Een container maken en beheren ^

Gebruik de opdracht om een ​​container te maken lxc init waaraan waarden worden doorgegeven репозиторий:образ en vervolgens de gewenste ID voor de container. De repository kan als lokaal worden opgegeven local: dat geldt ook voor elke mondiale situatie. Als de repository niet is opgegeven, wordt standaard de lokale repository gebruikt om naar de afbeelding te zoeken. Als de afbeelding is opgegeven vanuit de globale opslagplaats, wordt de afbeelding eerst gedownload naar de lokale opslagplaats en vervolgens gebruikt om de container te maken.

Laten we de volgende opdracht uitvoeren om onze eerste container te maken:

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

Laten we eens kijken naar de opdrachttoetsen die we hier in volgorde gebruiken:

• alpine3 — Er is een alias (alias) opgegeven voor de afbeelding die eerder naar de lokale opslagplaats is geüpload. Als er voor deze afbeelding geen alias is aangemaakt, kunt u altijd naar de afbeelding verwijzen met de bijbehorende afbeelding Vingerafdruk die in de tabel wordt weergegeven.
• alp — Stelt de identificatie voor de container in
• --storage — Deze sleutel geeft aan waarin Opslagpool Er wordt een container gemaakt
• --profile — Deze sleutels passen in cascade de configuratie van eerder gemaakte configuratieprofielen toe op de container

We lanceren de container, die het init-systeem van de distributie begint te lanceren:

lxc start alp

Je kunt ook de opdracht gebruiken lxc launch waarmee je teams kunt combineren lxc init и lxc start in één operatie.

Controle van de staat van de container:

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

De containerconfiguratie controleren:

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

In de sectie profiles we kunnen ervoor zorgen dat deze container twee configuratieprofielen gebruikt − default и hddroot. In sectie devices we kunnen slechts één apparaat detecteren omdat het netwerkapparaat op profielniveau is gemaakt default. Om alle apparaten te zien die door de container worden gebruikt, moet u een sleutel toevoegen --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: ""

Een statisch IP-adres instellen ^

Als we proberen een IP-adres in te stellen voor een netwerkapparaat eth0 team lxc config device set alp bedoeld voor de containerconfiguratie, dan ontvangen we een foutmelding die meldt dat het apparaat niet bestaat omdat het apparaat eth0 die door de container wordt gebruikt, behoort tot het profiel default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

We kunnen er uiteraard een statisch IP-adres voor instellen eth0 apparaten in het profiel, maar het zal hetzelfde zijn voor alle containers die dit profiel zullen gebruiken. Laten we daarom een ​​apparaat toevoegen dat speciaal voor de container is bedoeld:

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

Vervolgens moet u de container opnieuw opstarten:

lxc restart alp

Als we nu naar de containerconfiguratie kijken, hoeven we de optie niet te gebruiken --expanded om het netwerkapparaat te zien eth0, omdat we het op containerniveau hebben gemaakt en vanuit het profiel over hetzelfde apparaat zijn gestroomd 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: ""

Een container verwijderen ^

Gebruik de opdracht om een ​​container te verwijderen lxc delete, maar voordat u de container verwijdert, moet deze worden gestopt met behulp van de opdracht lxc stop:

lxc stop alp

lxc list

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

Nadat wij hebben vastgesteld dat de staat van de container is geworden GESTOPT, het kan worden verwijderd Opslagpool:

lxc delete alp

Toegang tot containers ^

Om opdrachten rechtstreeks in een container uit te voeren, waarbij netwerkverbindingen worden omzeild, gebruikt u de opdracht lxc exec die opdrachten in de container uitvoert zonder de systeemshell te starten. Als je een commando in een shell moet uitvoeren met behulp van shell-patronen zoals variabelen, bestandsomleidingen (pipe), enz., dan moet je de shell expliciet starten en het commando doorgeven als een sleutel, bijvoorbeeld:

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

De opdracht gebruikte een speciaal escape-teken voor speciaal karakter $ zodat de variabele $HOME werd niet geïnterpreteerd op de hostmachine, maar alleen binnen de container.

Het is ook mogelijk om de interactieve shell-modus te starten en vervolgens de sessie te beëindigen door een sneltoets uit te voeren CTRL+D:

lxc exec alp -- /bin/sh

Beheer van containerresources ^

In LXD kunt u containerbronnen beheren met behulp van een speciale set configuraties. U kunt een volledige lijst met containerconfiguratieparameters vinden bij documentatie.

Beperking van RAM-bronnen ^

Parameter limits.memory beperkt de hoeveelheid RAM die beschikbaar is voor de container. De waarde is een getal en één van beschikbare achtervoegsels.

Laten we de RAM-limiet van de container instellen op 256 MB:

lxc config set alp limits.memory 256MB

Er zijn ook andere parameters om het geheugen te beperken:

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

Team lxc config show Hiermee kunt u de volledige containerconfiguratie weergeven, inclusief de toegepaste resourcelimiet die is ingesteld:

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-bronlimiet ^

Er zijn verschillende manieren om CPU-bronnen te beperken. soorten beperkingen:

• limit.cpu - bindt een container aan een of meer CPU-kernen
• limits.cpu.allowance - beheert CFS-plannerquota wanneer de tijdslimiet is verstreken, of het universele mechanisme voor het delen van CPU-bronnen wanneer het percentage is verstreken
• limits.cpu.priority - Scheduler-prioriteit wanneer aan meerdere instanties die een set processors delen, hetzelfde percentage processors wordt toegewezen

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

Beperking van schijfruimte ^

Naast beperkingen zoals limits.read, limits.write we kunnen ook de hoeveelheid schijfruimte beperken die door de container wordt verbruikt (werkt alleen met ZFS of BTRFS):

lxc config device set alp root size=2GB

Na installatie, in de parameter devices.root.size We kunnen de ingestelde limiet verifiëren:

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

Om de gebruikte schijfquota te bekijken, kunnen we de opdracht gebruiken 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

Ondanks het feit dat we een limiet voor het rootapparaat van de container hebben ingesteld op 2 GB, kunnen systeemhulpprogramma's zoals df zal deze beperking niet zien. Om dit te doen, zullen we een kleine test uitvoeren en ontdekken hoe het werkt.

Laten we twee nieuwe, identieke containers in dezelfde container maken Opslagpool (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         |
+------+---------+------------------+------+-----------+-----------+

Laten we een bestand van 1 GB maken in een van de containers:

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

Laten we ervoor zorgen dat het bestand is gemaakt:

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

Als we in de tweede container kijken en controleren of er een bestand op dezelfde locatie bestaat, dan zal dit bestand daar niet zijn, wat te verwachten is, aangezien containers in hun eigen container worden gemaakt Opslagvolume in hetzelfde Opslagpool:

lxc exec alp2 -- ls -lh
total 0

Maar laten we de waarden die het produceert vergelijken df op de ene en de andere 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% /
...

Устройство /dev/loop1 gemount zoals de rootpartitie Opslagpool waarvan deze containers gebruik maken, dus delen ze het volume tussen twee.

Statistieken over het verbruik van hulpbronnen ^

U kunt statistieken over het resourceverbruik voor een container bekijken met behulp van de opdracht:

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

Werken met momentopnamen ^

LXD heeft de mogelijkheid om snapshots te maken en de containerstatus hiervan te herstellen.

Om een ​​momentopname te maken, voert u de volgende opdracht uit:

lxc snapshot alp snapshot1

Het team lxc snapshot geen sleutel aanwezig listOm de lijst met snapshots te bekijken, moet u daarom de opdracht gebruiken die algemene informatie over de container weergeeft:

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

U kunt een container vanuit een momentopname herstellen met behulp van de opdracht lxc restore waarbij de container wordt opgegeven waarvoor het herstel wordt uitgevoerd en de snapshot-alias:

lxc restore alp snapshot1

De volgende opdracht wordt gebruikt om een ​​momentopname te verwijderen. Houd er rekening mee dat de syntaxis van de opdracht niet vergelijkbaar is met die van alle andere; hier moet u een schuine streep naar voren achter de containernaam opgeven. Als de schuine streep wordt weggelaten, wordt het commando om een ​​momentopname te verwijderen geïnterpreteerd als een commando om een ​​container te verwijderen!

lxc delete alp/snapshot1

In het bovenstaande voorbeeld hebben we gekeken naar zogenaamde stateless snapshots. LXD heeft een ander type snapshots: stateful, waarmee de huidige status van alle processen in de container wordt opgeslagen. Er zijn een aantal interessante en nuttige functies verbonden aan stateful snapshots.

Wat nog meer? ^

• Er is een module beschikbaar voor Python-ontwikkelaars PyLXD die een API biedt aan LXD

UPDATE 10.04.2020/15/00 XNUMX:XNUMX: Navigatie toegevoegd

Bron: www.habr.com