LXD est le gestionnaire de conteneurs système de nouvelle génération, donc il dit source. Il offre une interface utilisateur similaire aux machines virtuelles, mais utilise à la place des conteneurs Linux.

Noyau LXD est un démon privilégié (un service exécuté avec les droits root) qui fournit une API REST via un socket Unix local, ainsi que via le réseau si la configuration appropriée est installée. Les clients, tels que l'outil de ligne de commande fourni avec LXD, effectuent des requêtes via cette API REST. Cela signifie que que vous accédiez à un hôte local ou à un hôte distant, tout fonctionne de la même manière.

Dans cet article, nous ne nous attarderons pas en détail sur les concepts de LXD, nous ne considérerons pas toutes les capacités disponibles décrites dans la documentation, y compris la récente implémentation dans les dernières versions de LXD du support des machines virtuelles QEMU en parallèle avec les conteneurs. Au lieu de cela, nous apprendrons uniquement les bases de la gestion des conteneurs : configuration des pools de stockage, mise en réseau, exécution d'un conteneur, application des limites de ressources et comment utiliser les instantanés afin que vous puissiez acquérir une compréhension de base de LXD et utiliser des conteneurs sous Linux.

Pour des informations complètes, veuillez vous référer à la source officielle :

• Site du développeur
• Documentation
• Forum

Navigation

• Installation LXD
  • Installer LXD sur les distributions Ubuntu
  • Installation de LXD sur les distributions Arch Linux
• Stockage LXD (stockage)
• Initialisation de LXD
  • Sélection d'un système de fichiers pour le pool de stockage
  • Initialisation du réseau et du pool de stockage à l'aide de l'assistant
  • Création d'un pool de stockage supplémentaire
    • Augmentation de la taille du pool de stockage
    • Insertion automatique d'un fichier de bouclage dans un emplacement de périphérique de bouclage
  • Sécurité. Privilèges de conteneur
  • Création d'un commutateur de réseau virtuel
  • Profil de configuration
    • Modification de votre profil
    • Création de nouveaux profils
  • Dépôt d'images
    • Dépôts d'images distants
    • Dépôt d'images local
  • Configuration LXD
• Créer et gérer un conteneur
  • Définir une adresse IP statique
  • Supprimer un conteneur
  • Accès aux conteneurs
  • Gestion des ressources des conteneurs
    • Limitation des ressources RAM
    • Limite des ressources CPU
    • Limitation de l'espace disque
    • Statistiques de consommation des ressources
  • Travailler avec des instantanés

Installation LXD ^

Installer LXD sur les distributions Ubuntu ^

Dans le package de distribution Ubuntu 19.10 lxd a une émission sur paquet instantané:

apt search lxd

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

Cela signifie que deux packages seront installés en même temps, l'un en tant que package système et l'autre en tant que package snap. L'installation de deux packages sur un système peut créer un problème dans lequel le package système peut devenir orphelin si le package snap est supprimé par le gestionnaire de packages snap.

Rechercher un forfait lxd dans le référentiel snap, vous pouvez utiliser la commande suivante :

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

En exécutant la commande list vous pouvez vous assurer que le colis lxd pas encore installé :

snap list

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

Bien que LXD soit un package snap, il doit être installé via le package système. lxd, qui créera le groupe correspondant dans le système, les utilitaires nécessaires dans /usr/bin etc.

sudo apt update
sudo apt install lxd

Assurons-nous que le package est installé en tant que package snap :

snap list

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

Installation de LXD sur les distributions Arch Linux ^

Pour installer le package LXD sur le système, vous devez exécuter les commandes suivantes, la première mettra à jour la liste des packages sur le système disponibles dans le référentiel, la seconde installera directement le package :

sudo pacman -Syyu && sudo pacman -S lxd

Après avoir installé le package, afin de gérer LXD par un utilisateur régulier, il doit être ajouté au groupe système lxd:

sudo usermod -a -G lxd user1

Assurons-nous que l'utilisateur user1 ajouté au groupe lxd:

id -Gn user1

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

Si le groupe lxd n'est pas visible dans la liste, vous devez alors réactiver la session utilisateur. Pour ce faire, vous devez vous déconnecter et vous connecter sous le même utilisateur.

Activer dans systemd chargement du service LXD au démarrage du système :

sudo systemctl enable lxd

Commençons le service :

sudo systemctl start lxd

Vérification de l'état du service :

sudo systemctl status lxd

Stockage LXD (stockage) ^

Avant de commencer l’initialisation, nous devons comprendre comment le stockage dans LXD est organisé logiquement.

Stockage (Stockage) se compose de d'un ou plusieurs Pool de stockage qui utilise l'un des systèmes de fichiers pris en charge tels que ZFS, BTRFS, LVM ou des répertoires standards. Chaque Pool de stockage est divisé en volumes (Volume de stockage) qui contiennent des images, des conteneurs ou des données à d'autres fins.

• Des images - ce sont des distributions spécialement assemblées sans le noyau Linux et disponibles à partir de sources externes
• Containers - ce sont des distributions déployées à partir d'images, prêtes à l'emploi
• Instantanés - ce sont des instantanés de l'état des conteneurs auxquels vous pouvez revenir

Pour gérer le stockage dans LXD, utilisez la commande lxc storage un certificat pour lequel vous pouvez obtenir en précisant la clé - lxc storage --help

La commande suivante affiche une liste de tous Pool de stockage dans le stockage LXD :

lxc storage list

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

Pour afficher une liste de tous Volume de stockage dans le sélectionné Pool de stockage sert l'équipe 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       |
+-----------+----------------------------------+-------------+---------+

Aussi, si pour Pool de stockage Lors de la création, le système de fichiers BTRFS a été sélectionné, puis obtenez une liste Volume de stockage ou sous-volumes dans l'interprétation BTRFS, vous pouvez utiliser la boîte à outils de ce système de fichiers :

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

Initialisation de LXD ^

Avant de créer et d'utiliser des conteneurs, vous devez effectuer une initialisation générale LXD qui crée et configure le réseau et le stockage. Cela peut être fait manuellement à l'aide des commandes client standard disponibles dans la liste en appelant la commande lxc --help ou en utilisant l'assistant d'initialisation lxd init répondre à quelques questions.

Sélection d'un système de fichiers pour le pool de stockage ^

Lors de l'initialisation, LXD pose plusieurs questions, notamment la détermination du type de système de fichiers pour le système par défaut. Pool de stockage. Par défaut, le système de fichiers BTRFS est sélectionné pour cela. Il sera impossible de passer à un autre FS après la création. Pour sélectionner un FS, il est suggéré tableau de comparaison des fonctionnalités:

Fonctionnalité
Annuaire
Btrfs
LVM
ZFS
CEPH

Stockage d'images optimisé
aucune
Oui
Oui
Oui
Oui

Création d'instance optimisée
aucune
Oui
Oui
Oui
Oui

Création d'instantanés optimisée
aucune
Oui
Oui
Oui
Oui

Transfert d'images optimisé
aucune
Oui
aucune
Oui
Oui

Transfert d'instance optimisé
aucune
Oui
aucune
Oui
Oui

Copie à l'écriture
aucune
Oui
Oui
Oui
Oui

Basé sur des blocs
aucune
aucune
Oui
aucune
Oui

Clonage instantané
aucune
Oui
Oui
Oui
Oui

Pilote de stockage utilisable à l'intérieur d'un conteneur
Oui
Oui
aucune
aucune
aucune

Restauration à partir d'anciens instantanés (pas les plus récents)
Oui
Oui
Oui
aucune
Oui

Quotas de stockage
Oui(*)
Oui
Oui
Oui
aucune

Initialisation du réseau et du pool de stockage à l'aide de l'assistant ^

La commande suivante que nous examinerons suggère de configurer les principaux composants de LXD en répondant à des questions simples à l'aide de l'assistant d'initialisation.

Exécuter la commande lxc init et saisissez les réponses aux questions après les deux points comme indiqué dans l'exemple ci-dessous ou modifiez-les selon vos conditions :

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

Création d'un pool de stockage supplémentaire ^

À l'étape précédente, nous avons créé Pool de stockage qui a reçu le nom ssdpool et dont le fichier se trouve sur mon système à l'adresse /var/lib/lxd/disks/ssdpool.img. Cette adresse du système de fichiers correspond au disque SSD physique de mon PC.

Les actions suivantes, pour approfondir la compréhension du rôle joué par Pool de stockage dans le dépôt, nous allons en créer un deuxième Pool de stockage qui sera physiquement situé sur un autre type de disque, le disque dur. Le problème est que LXD ne vous permet pas de créer Pool de stockage hors adresse /var/lib/lxd/disks/ et même les liens symboliques ne fonctionneront pas, voir la réponse du développeur. Nous pouvons contourner cette limitation lors de l'initialisation/formatage Pool de stockage en spécifiant la valeur en tant que périphérique bloc au lieu du chemin d'accès au fichier de bouclage en le spécifiant dans la clé source.

Alors avant de créer Pool de stockage vous devez définir un fichier de bouclage ou une partition existante sur votre système de fichiers qu'il utilisera. Pour ce faire, nous allons créer et utiliser un fichier dont nous limiterons la taille à 10 Go :

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

Connectons le fichier de bouclage à un périphérique de bouclage gratuit :

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

/dev/loop1

Merci à la clé --show l'exécution de la commande renvoie à l'écran le nom de l'appareil auquel notre fichier de bouclage est connecté. Si nécessaire, nous pouvons afficher une liste de tous les appareils occupés de ce type pour nous assurer que nos actions sont correctes :

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

Dans la liste, vous pouvez constater que l'appareil a /dev/loop1 fichier de bouclage inclus /mnt/work/lxd/hddpool.img, et dans l'appareil /dev/loop0 fichier de bouclage inclus /var/lib/lxd/disks/ssdpool.img ce qui correspond à la valeur par défaut Pool de stockage.

La commande suivante en crée un nouveau Pool de stockage dans LXD sur la base du fichier de bouclage que nous venons de préparer. LXD formatera le fichier de bouclage /mnt/work/lxd/hddpool.img dans l'appareil /dev/loop1 pour le système de fichiers BTRFS :

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

Affichons une liste de tous Pool de stockage à l'écran:

lxc storage list

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

Augmentation de la taille du pool de stockage ^

Après la création Pool de stockage, si nécessaire, il peut être étendu. Pour Pool de stockage en fonction du système de fichiers BTRFS, exécutez les commandes suivantes :

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

Insertion automatique d'un fichier de bouclage dans un emplacement de périphérique de bouclage ^

Nous avons un petit problème, lors du redémarrage du système hôte, le fichier /mnt/work/lxd/hddpool.img va "voler" hors de l'appareil /dev/loop1 et le service LXD plantera lors du chargement car il ne le verra pas sur cet appareil. Pour résoudre ce problème, vous devez créer un service système qui insérera ce fichier dans l'appareil /dev/loop1 lorsque le système hôte démarre.

créons unité Type de fichier service в /etc/systemd/system/ pour le système d'initialisation SystemD :

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

Activez le service :

sudo systemctl enable lxd-hddpool

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

Après avoir redémarré le système hôte, nous vérifions l'état du service :

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

À partir du résultat, nous pouvons vérifier que l'état du service est infection, malgré le fait que l'exécution de notre script à partir d'une commande était terminée, l'option nous a permis de le faire RemainAfterExit=true.

Sécurité. Privilèges de conteneur ^

Étant donné que tous les processus conteneurs s'exécutent en fait de manière isolée sur le système hôte à l'aide de son noyau, pour protéger davantage l'accès des processus conteneurs au système hôte, LXD offre le privilège de processus, où :

• Conteneurs privilégiés - ce sont des conteneurs dans lesquels les processus avec UID et GID correspondent au même propriétaire que sur le système hôte. Par exemple, un processus exécuté dans un conteneur avec un UID de 0 a tous les mêmes droits d'accès qu'un processus sur le système hôte avec un UID de 0. En d'autres termes, l'utilisateur root dans le conteneur a tous les droits non seulement dans le conteneur, mais aussi sur le système hôte s'il peut sortir de l'espace de noms isolé du conteneur.

• Conteneurs non privilégiés - ce sont des conteneurs dans lesquels les processus appartiennent au propriétaire de l'UID et du GID avec un numéro de 0 à 65535, mais pour le système hôte, le propriétaire est masqué à l'aide des bits SubUID et SubGID ajoutés, respectivement. Par exemple, un utilisateur avec UID=0 dans un conteneur sera vu sur le système hôte comme SubUID + UID. Cela protège le système hôte, car si un processus dans le conteneur est capable de s'échapper de son espace de noms isolé, il ne peut communiquer avec le système hôte qu'en tant que processus avec un UID/GID inconnu et très élevé.

Par défaut, les conteneurs nouvellement créés ont un statut non privilégié et nous devons donc définir un SubUID et un SubGID.

Créons deux fichiers de configuration dans lesquels nous définirons respectivement le masque pour SubUID et SubGID :

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

Pour appliquer les modifications, le service LXD doit être redémarré :

sudo systemctl restart lxd

Création d'un commutateur de réseau virtuel ^

Puisque nous avons précédemment initialisé le réseau à l'aide de l'assistant d'initialisation lxd init et créé un périphérique réseau lxdbr0, puis dans cette section, nous nous familiariserons simplement avec la mise en réseau dans LXD et comment créer un commutateur virtuel (pont) à l'aide de la commande client.

Le diagramme suivant montre comment un commutateur (pont) connecte l'hôte et les conteneurs à un réseau :

Les conteneurs peuvent communiquer via un réseau avec d'autres conteneurs ou avec l'hôte sur lequel ces conteneurs sont servis. Pour ce faire, vous devez relier les cartes réseau virtuelles des conteneurs avec un commutateur virtuel. Nous allons d'abord créer un commutateur, et les interfaces réseau du conteneur seront liées dans les chapitres suivants, une fois le conteneur lui-même créé.

La commande suivante crée un commutateur avec un sous-réseau 10.0.5.0/24 et adresse IPv4 10.0.5.1/24, et comprend également ipv4.nat afin que les conteneurs puissent accéder à Internet via l'hôte en utilisant le service NAT :

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

Vérification de la liste des périphériques réseau disponibles dans LXD :

lxc network list

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

Vous pouvez également vérifier qu'un périphérique réseau a été créé à l'aide de l'outil standard de la distribution Linux - ip link ou 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

Profil de configuration ^

Chaque conteneur dans LXD a sa propre configuration et peut l'étendre avec des configurations déclarées globalement appelées profils de configuration. L'application de profils de configuration à un conteneur a un modèle en cascade, l'exemple suivant le démontre :

Dans cet exemple, trois profils ont été créés dans le système LXD : default, hddpool и hostfs. Les trois profils sont appliqués à un conteneur qui a une configuration locale (zone grise). Profil default possède un appareil root qui a un paramètre pool est ssdpool, mais grâce au modèle d'application de configuration en cascade, nous pouvons appliquer un profil au conteneur hddpool qui a un paramètre pool remplacera le même paramètre du profil default et le conteneur recevra la configuration de l'appareil root avec paramètre pool égal hddpool, et le profil hostfs ajoute simplement un nouveau périphérique au conteneur.

Pour voir la liste des profils de configuration disponibles, utilisez la commande suivante :

lxc profile list

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

Une liste complète des commandes disponibles pour travailler avec un profil peut être obtenue en ajoutant la clé --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

Modification de votre profil ^

Profil de configuration par défaut default n'a pas de configuration de carte réseau pour le conteneur et tous les conteneurs nouvellement créés n'ont pas de réseau, pour eux, il est nécessaire de créer des périphériques réseau locaux (dédiés) avec une commande séparée, mais nous pouvons créer un périphérique réseau global dans la configuration profil qui sera partagé entre tous les conteneurs utilisant ce profil. De cette façon, immédiatement après la commande de création d’un nouveau conteneur, ils disposeront d’un réseau avec accès au réseau. En même temps, il n'y a aucune restriction, nous pouvons toujours créer un périphérique réseau local plus tard si nécessaire.

La commande suivante ajoutera l'appareil au profil de configuration eth0 типа nic connecté au réseau lxdbr0:

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

Il est important de noter que puisque nous avons effectivement ajouté l'appareil au profil de configuration, si nous avons spécifié une adresse IP statique dans l'appareil, alors tous les conteneurs qui utiliseront ce profil partageront la même adresse IP. S'il est nécessaire de créer un conteneur avec une adresse IP statique allouée au conteneur, vous devez alors créer une configuration de périphérique réseau au niveau du conteneur (configuration locale) avec le paramètre d'adresse IP, et non au niveau du profil.

Vérifions le profil :

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

Dans ce profil, nous pouvons voir que pour tous les conteneurs nouvellement créés, deux appareils seront créés :

• eth0 - Type d'appareil nic connecté à un switch (pont réseau) lxdbr0
• root - Type d'appareil disk qui utilise un pool de stockage ssdpool

Création de nouveaux profils ^

Pour utiliser précédemment créé Pool de stockage conteneurs, créer un profil de configuration ssdroot dans lequel nous ajouterons un appareil comme disk avec point de montage / (racine) en utilisant le fichier créé précédemment Pool de stockage - ssdpool:

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

De même, nous créons un appareil comme disk, mais dans ce cas en utilisant Pool de stockage - hddpool:

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

Vérification des profils de configuration :

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

Dépôt d'images ^

Les conteneurs sont créés à partir d'images provenant de distributions spécialement assemblées ne possédant pas de noyau Linux. Par conséquent, avant d’exécuter le conteneur, il doit être déployé à partir de cette image. La source des images est un référentiel local dans lequel les images sont téléchargées à partir de référentiels externes.

Dépôts d'images distants ^

Par défaut, LXD est configuré pour recevoir des images de trois sources distantes :

• ubuntu : (pour les images Ubuntu stables)
• Ubuntu-quotidiennement : (pour les images Ubuntu quotidiennes)
• images: (pour un tas d'autres distributions)

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

Par exemple, le dépôt ubuntu: contient les images suivantes :

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

Pour afficher un nombre limité de colonnes nous avons utilisé l'option -c avec paramètres dasut, et a également limité la longueur de la liste avec la commande head.

Le filtrage est disponible pour afficher une liste d’images. La commande suivante listera toutes les architectures de distribution disponibles 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        |
+------------------------------+--------------------------------------+--------------+

Dépôt d'images local ^

Pour commencer à utiliser le conteneur, vous devez ajouter une image du référentiel global au référentiel local local:. Maintenant le dépôt local est vide, la commande s'en assurera lxc image list. Si la méthode list ne spécifiez pas de référentiel, alors le référentiel local sera utilisé par défaut - local:

lxc image list local:

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

Les images du référentiel sont gérées à l'aide des méthodes suivantes :

Équipe
description

image lxc alias
Gérer les alias d'images

image lxc copier
Copier des images entre serveurs

image lxc effacer
Supprimer des images

image lxc éditer
Modifier les propriétés de l'image

image lxc Exporter
Exporter et télécharger des images

image lxc importer
Importer des images dans le magasin d'images

image lxc info
Afficher des informations utiles sur les images

image lxc liste
Lister les images

image lxc rafraîchir
Actualiser les images

image lxc montrer
Afficher les propriétés de l'image

Copiez l'image dans le référentiel local à partir du référentiel global images::

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

Image copied successfully!

Affichons une liste de toutes les images actuellement disponibles dans le référentiel local local::

lxc image -c lfdatsu list local:

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

Configuration LXD ^

En plus du mode interactif, LXD prend également en charge un mode d'installation de configuration non interactif, c'est-à-dire lorsque la configuration est spécifiée sous la forme d'un fichier YAML, un format spécial qui permet d'installer toute la configuration en une seule fois, en contournant l'exécution. de nombreuses commandes interactives abordées ci-dessus dans cet article, notamment la configuration du réseau, la création de profils de configuration, etc. Nous ne couvrirons pas ce domaine ici, vous pouvez le vérifier par vous-même. dans la documentation.

Commande interactive suivante lxc config que nous allons examiner vous permet de définir la configuration. Par exemple, pour garantir que les images téléchargées dans le référentiel local ne sont pas automatiquement mises à jour depuis les référentiels globaux, nous pouvons activer ce comportement avec la commande suivante :

lxc config set images.auto_update_cached=false

Créer et gérer un conteneur ^

Pour créer un conteneur utilisez la commande lxc init auquel les valeurs sont transmises репозиторий:образ puis l'ID souhaité pour le conteneur. Le référentiel peut être spécifié comme local local: il en va de même pour n’importe quel système mondial. Si le référentiel n'est pas spécifié, le référentiel local est utilisé par défaut pour rechercher l'image. Si l'image est spécifiée à partir du référentiel global, elle sera d'abord téléchargée vers le référentiel local, puis utilisée pour créer le conteneur.

Exécutons la commande suivante pour créer notre premier conteneur :

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

Regardons les touches de commande que nous utilisons ici dans l'ordre :

• alpine3 — Un alias (alias) est spécifié pour l'image précédemment téléchargée vers le référentiel local. Si l'alias n'a pas été créé pour cette image, vous pouvez toujours faire référence à l'image par son Empreinte Digitale qui est affiché dans le tableau.
• alp — Définit l'identifiant du conteneur
• --storage — Cette touche indique dans quel Pool de stockage un conteneur sera créé
• --profile — Ces clés appliquent en cascade la configuration des profils de configuration précédemment créés au conteneur

On lance le conteneur, qui commence à lancer le système init de la distribution :

lxc start alp

Vous pouvez également utiliser la commande lxc launch ce qui permet de regrouper des équipes lxc init и lxc start en une seule opération.

Vérification de l'état du conteneur :

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

Vérification de la configuration du conteneur :

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

Dans la section profiles nous pouvons nous assurer que ce conteneur utilise deux profils de configuration - default и hddroot. Dans la section devices nous ne pouvons détecter qu'un seul appareil car le périphérique réseau a été créé au niveau du profil default. Afin de voir tous les appareils utilisés par le conteneur, vous devez ajouter une clé --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: ""

Définir une adresse IP statique ^

Si nous essayons de définir une adresse IP pour un périphérique réseau eth0 l'équipe lxc config device set alp destiné à la configuration du conteneur, nous recevrons alors une erreur qui signalera que le périphérique n'existe pas car le périphérique eth0 qui est utilisé par le conteneur appartient au profil default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Nous pouvons bien sûr définir une adresse IP statique pour eth0 appareils dans le profil, mais il en sera de même pour tous les conteneurs qui utiliseront ce profil. Ajoutons donc un périphérique dédié au conteneur :

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

Ensuite, vous devez redémarrer le conteneur :

lxc restart alp

Si nous regardons maintenant la configuration du conteneur, nous n'avons pas besoin d'utiliser l'option --expanded pour voir le périphérique réseau eth0, puisque nous l'avons créé au niveau du conteneur et qu'il a été diffusé en cascade sur le même appareil à partir du profil 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: ""

Supprimer un conteneur ^

Pour supprimer un conteneur, utilisez la commande lxc delete, mais avant de retirer le conteneur, il faut l'arrêter à l'aide de la commande lxc stop:

lxc stop alp

lxc list

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

Après avoir vérifié que l'état du conteneur est devenu ARRÊTÉ, il peut être supprimé de Pool de stockage:

lxc delete alp

Accès aux conteneurs ^

Pour exécuter des commandes directement dans un conteneur, en contournant les connexions réseau, utilisez la commande lxc exec qui exécute les commandes dans le conteneur sans lancer le shell système. Si vous devez exécuter une commande dans un shell en utilisant des modèles de shell tels que des variables, des redirections de fichiers (pipe), etc., vous devez alors lancer explicitement le shell et transmettre la commande sous forme de clé, par exemple :

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

La commande a utilisé un caractère d'échappement spécial pour caractère spécial $ pour que la variable $HOME n'a pas été interprété sur la machine hôte, mais a été interprété uniquement à l'intérieur du conteneur.

Il est également possible de démarrer le mode shell interactif, puis de terminer la session en exécutant le raccourci clavier CTRL+D:

lxc exec alp -- /bin/sh

Gestion des ressources des conteneurs ^

Dans LXD, vous pouvez gérer les ressources du conteneur à l'aide d'un ensemble spécial de configuration. Une liste complète des paramètres de configuration du conteneur peut être trouvée dans la documentation.

Limitation des ressources RAM ^

Paramètre limits.memory limite la quantité de RAM disponible pour le conteneur. La valeur est un nombre et l'un des suffixes disponibles.

Fixons la limite de RAM du conteneur à 256 Mo :

lxc config set alp limits.memory 256MB

Il existe également d'autres paramètres pour limiter la mémoire :

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

Équipe lxc config show vous permet d'afficher l'intégralité de la configuration du conteneur, y compris la limite de ressources appliquée qui a été définie :

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

Limite des ressources CPU ^

Il existe plusieurs façons de limiter les ressources du processeur. types de restrictions:

• limit.cpu - lie un conteneur à un ou plusieurs cœurs de processeur
• limits.cpu.allowance - gère soit les quotas du planificateur CFS lorsque la limite de temps est dépassée, soit le mécanisme universel de partage des ressources CPU lorsque le pourcentage est dépassé
• limits.cpu.priority - priorité du planificateur lorsque plusieurs instances partageant un ensemble de processeurs se voient attribuer le même pourcentage de processeurs

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

Limitation de l'espace disque ^

En plus des restrictions telles limits.read, limits.write on peut également limiter la quantité d'espace disque consommé par le conteneur (fonctionne uniquement avec ZFS ou BTRFS) :

lxc config device set alp root size=2GB

Après installation, dans le paramètre devices.root.size Nous pouvons vérifier la limite fixée :

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

Pour afficher les quotas de disque utilisés, nous pouvons obtenir à partir de la commande 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

Malgré le fait que nous ayons fixé une limite pour le périphérique racine du conteneur à 2 Go, les utilitaires système tels que df ne verra pas cette restriction. Pour ce faire, nous allons effectuer un petit test et découvrir comment cela fonctionne.

Créons 2 nouveaux conteneurs identiques dans le même Pool de stockage (pool disque dur) :

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

Créons un fichier de 1 Go dans l'un des conteneurs :

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

Assurons-nous que le fichier est créé :

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

Si nous regardons dans le deuxième conteneur, vérifions l'existence d'un fichier au même emplacement, alors ce fichier ne sera pas là, ce qui est attendu, puisque les conteneurs sont créés dans leur propre Volume de stockage dans le même Pool de stockage:

lxc exec alp2 -- ls -lh
total 0

Mais comparons les valeurs qu'il produit df sur l'un et l'autre conteneur :

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

Appareil /dev/loop1 monté car la partition racine est Pool de stockage que ces conteneurs utilisent, ils partagent donc son volume entre deux.

Statistiques de consommation des ressources ^

Vous pouvez afficher les statistiques de consommation des ressources pour un conteneur à l'aide de la commande :

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

Travailler avec des instantanés ^

LXD a la capacité de créer des instantanés et de restaurer l'état du conteneur à partir d'eux.

Pour créer un instantané, exécutez la commande suivante :

lxc snapshot alp snapshot1

Équipe lxc snapshot aucune clé disponible list, par conséquent, pour afficher la liste des instantanés, vous devez utiliser la commande qui affiche des informations générales sur le conteneur :

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

Vous pouvez restaurer un conteneur à partir d'un instantané à l'aide de la commande lxc restore en spécifiant le conteneur pour lequel la restauration sera effectuée et l'alias de l'instantané :

lxc restore alp snapshot1

La commande suivante est utilisée pour supprimer un instantané. Veuillez noter que la syntaxe de la commande n'est pas similaire à toutes les autres ; ici, vous devez spécifier une barre oblique après le nom du conteneur. Si la barre oblique est omise, alors la commande de suppression d'un instantané est interprétée comme une commande de suppression d'un conteneur !

lxc delete alp/snapshot1

Dans l’exemple ci-dessus, nous avons examiné ce que l’on appelle les instantanés sans état. LXD propose un autre type d'instantanés - avec état, qui enregistre l'état actuel de tous les processus dans le conteneur. Il existe un certain nombre de fonctionnalités intéressantes et utiles associées aux instantanés avec état.

Quoi d'autre? ^

• Un module est disponible pour les développeurs Python PyLXD qui fournit une API à LXD

MISE À JOUR 10.04.2020/15/00 XNUMXhXNUMX : Ajout de la navigation

Source: habr.com