Skip to content

Changes

Page history
Title modified authored by BAILLY-REYRE Aurélien's avatar BAILLY-REYRE Aurélien
Show whitespace changes
Inline Side-by-side
Cloudatlpnhe.md 0 → 100644
View page @ 2b2a9f33
# Cloud Openstack #
Cette documentation a été rédigée initialement par Jérôme Pansanel (IPHC) pour la [plateforme
SCIGNE](https://grand-est.fr/) et est distribuée sous licence libre dans le cadre de France Grille Cloud.
Elle a été adaptée aux spécificités de la plateforme cloud Openstack du LPNHE.
# Introduction
Le service de Cloud Computing IaaS (*Infrastructure as a Service*) permet aux utilisateurs de démarrer des
machines virtuelles (*VM*) de manière indépendante, et d'orchestrer ces
déploiements pour créer des infrastructures de calcul à la demande.
L'utilisateur peut choisir le système d'exploitation et le gabarit
(nombre de coeurs, quantité de mémoire et de disque) de chacune de ces
machines. Le fonctionnement de ce service repose sur le logiciel
[OpenStack](http://www.openstack.org).
Grâce aux différents modules disponibles (authentification, gestion des
images, gestion du stockage, conteneurs à la demande, ordonnanceur,
...), OpenStack permet de piloter une infrastructure Cloud et de fournir
un ensemble complet de services aux utilisateurs.
Cette documentation détaille l'utilisation du client en ligne de
commande (ou **CLI** pour *Command Line Interface*) `openstack` interagissant avec les modules OpenStack pour
utiliser efficacement le service de Cloud Computing IaaS. Une
alternative à l'utilisation de la ligne de commande est d'utiliser
[l'interface Web Horizon](https://lpnhe-cloud028.in2p3.fr/dashboard/).
# CLI: étapes obligatoires
## Définition des variables d'environnement
Pour pouvoir utiliser le service cloud, vous devez au préalable vous connecter via ssh (en utilisant le *login/password* de votre compte mail) à la passerelle correspondant à votre projet :
``` {.sourceCode .console}
$ ssh username@IP_PROJECT_SSHGATE
```
où le champ `IP_PROJECT_SSHGATE` est à remplacer par l'adresse IP qui vous a été communiquée par mail.
Il faut maintenant configurer le client. Pour cela, créer
le fichier `${HOME}/.cloud.env` avec le contenu suivant (les
valeurs *username*, *password* et *projectname* sont à remplacer par celles qui vous
ont été transmises lors de la création de votre compte sur le service) :
``` {.sourceCode .bash}
export OS_PROJECT_DOMAIN_NAME=default
export OS_USER_DOMAIN_NAME=default
export OS_PROJECT_NAME=projectname
export OS_USERNAME=username
export OS_PASSWORD=password
export OS_AUTH_URL=http://134.158.159.28:35357/v3
export OS_IDENTITY_API_VERSION=3
export OS_IMAGE_API_VERSION=2
```
Assurez-vous, avec la commande suivante, qu'il ne soit pas accessible à d'autres utilisateurs que vous :
``` {.sourceCode .console}
$ chmod 0400 ${HOME}/.cloud.env
```
Une fois ce fichier créé, il doit être *sourcé* pour charger les
différentes variables d'environnement dans votre shell actuel :
``` {.sourceCode .console}
$ source ${HOME}/.cloud.env
```
Il est nécessaire de réaliser cette étape à chaque fois que vous lancez
un nouveau shell, à moins que vous n'ajoutiez la commande *source*
précédente au fichier d'initialisation de votre shell (par exemple, le
fichier `${HOME}/.bashrc` pour le shell `bash`).
Vous pouvez maintenant tester que votre client fonctionne et qu'il
arrive à se connecter correctement au Cloud :
``` {.sourceCode .console}
$ openstack server list
```
> **IMPORTANT**
>
> Toutes les commandes du type `openstack [...]` de cette documentation ne peuvent être
> exécutées que sur la passerelle correspondant à votre projet.
>
## Changement du mot de passe
Il est fortement conseillé de changer votre mot de passe avant votre
première utilisation du service. Pour cela, utilisez la commande
suivante :
``` {.sourceCode .console}
$ openstack user password set
Current Password:
New Password:
Repeat New Password:
You should update the password you are using to authenticate to match your new password
```
Après avoir effectué cette opération, votre nouveau mot de passe est
changé côté serveur, mais il n'est pas encore pris en compte coté client :
``` {.sourceCode .console}
$ openstack server list
ERROR: Invalid OpenStack Nova credentials.
```
Il faut modifier aussi la variable d'environnement correspondante :
``` {.sourceCode .console}
$ export OS_PASSWORD=MY_NEW_PASSWORD
$ openstack server list
+--------------------------------------+-------+--------+-------------------------------+----------------------+
| ID | Name | Status | Networks | Image Name |
+--------------------------------------+-------+--------+-------------------------------+----------------------+
| 36dd1e32-2a79-4e78-a4e1-999335de3cbd | MY_VM | ACTIVE | project_network=192.168.34.25 | Debian-9 |
+--------------------------------------+-------+--------+-------------------------------+----------------------+
```
Si cette dernière commande s'effectue avec succès, vous pouvez
maintenant mettre le fichier `${HOME}/.cloud.env` à jour avec
votre nouveau mot de passe.
Une fois que vous avez mis à jour le mot de passe dans le fichier
`${HOME}/.cloud.env`, il est nécessaire de *sourcer* à nouveau
ce fichier pour que son nouveau contenu soit pris en compte.
L'aide en ligne est disponible :
``` {.sourceCode .console}
$ openstack help user set
Change current user password
optional arguments:
-h, --help show this help message and exit
--password <new-password>
New user password
--original-password <original-password>
Original user password
```
## Gestion de la clé SSH
Afin de pouvoir se connecter à la machine virtuelle, il est nécessaire
d'utiliser une clé SSH et de l'enregistrer auprès du serveur OpenStack.
``` {.sourceCode .console}
$ ssh-keygen -t rsa -b 4096
[...]
$ openstack keypair create --public-key=${HOME}/.ssh/id_rsa.pub ${USER}_key
$ openstack keypair list
+----------+-------------------------------------------------+
| Name | Fingerprint |
+----------+-------------------------------------------------+
| cloudkey | 33:91:4b:38:52:63:1d:18:7b:e0:e3:0d:3b:63:ce:4b |
+----------+-------------------------------------------------+
```
La commande `ssh-keygen -t rsa -b 4096` génère par défaut une clé privée `id_rsa` et une clé publique `id_rsa.pub` dans le dossier `.ssh/`. La clé privée ne doit jamais être communiquée.
# Gestion des machines virtuelles
Cette partie décrit la gestion des machines virtuelles.
## Découverte de l'environnement OpenStack
Quelques commandes permettent de voir les éléments disponibles pour
construire son image virtuelle. Tout d'abord, la liste des images de
systèmes d'exploitation pour les machines virtuelles est obtenue avec :
``` {.sourceCode .console}
$ openstack image list
+--------------------------------------+----------+--------+
| ID | Name | Status |
+--------------------------------------+----------+--------+
| 4ad9e79e-b97d-4647-bb34-5b99a45d8fe6 | CentOS-6 | active |
| 3abfbd5d-e07b-4187-b2d2-c58a51bf86b6 | CentOS-7 | active |
| 3eaac2ba-d601-4c17-b4ee-7a7499fe7670 | Debian-9 | active |
+--------------------------------------+----------+--------+
```
> **note**
>
> La liste des images disponibles n'étant pas figée (les images sont
> mises à jour réguliérement), il est fort probable que vous obteniez un
> résultat un peu différent.
Ensuite, la liste des gabarits de machines virtuelles (*flavor*)
disponibles est affichée avec :
``` {.sourceCode .console}
$ openstack flavor list
+--------------------------------------+--------------+------+------+-----------+-------+-----------+
| ID | Name | RAM | Disk | Ephemeral | VCPUs | Is Public |
+--------------------------------------+--------------+------+------+-----------+-------+-----------+
| 0f82a5b4-c91b-4a1b-81a9-b627164a6f10 | 4CPU_8GB-RAM | 8192 | 0 | 0 | 4 | True |
| 1244c110-32cc-41ef-b687-bf2111988963 | 1CPU_2GB-RAM | 2048 | 0 | 0 | 1 | True |
| c60ae355-31ec-4b70-a214-0e42f868f752 | m1.nano | 64 | 1 | 0 | 1 | True |
| c7afb67f-7ffc-4932-96ea-4eed61cd0254 | 2CPU_4GB-RAM | 4096 | 0 | 0 | 2 | True |
+--------------------------------------+--------------+------+------+-----------+-------+-----------+
```
Enfin, pour connaître les réseaux utilisables par la machine virtuelle,
utilisez :
``` {.sourceCode .console}
$ openstack network list
+--------------------------------------+-----------------+--------------------------------------+
| ID | Name | Subnets |
+--------------------------------------+-----------------+--------------------------------------+
| 14fea0a6-930e-42ad-aba1-1d3237aef0e1 | uplink_v4 | cc3d1897-71a0-4582-ae61-f37603956be0 |
| 4ffd28df-f402-4e38-9366-2ec042224645 | project_network | 7be94109-f12e-4b2f-8f3e-33ae74248894 |
+--------------------------------------+-----------------+--------------------------------------+
```
Dans le tableau précédent, nous remarquons que deux réseaux sont
disponibles, `uplink_v4` et `project_network`. Le réseau
`uplink_v4` est utilisé pour fournir une adresse IP publique à la passerelle `project_sshgate`. Cette passerelle vous permet de vous connecter depuis le laboratoire aux machines virtuelles que vous créez. Ces dernières ont une adresse IP privée attribuée par le réseau `project_network` et ne sont donc pas accessible directement. Donc lorsque vous créerez vos machines, le réseau que vous devez utiliser est `project_network`.
Lancement de la machine virtuelle ( VM )
----------------------------------------
Dans la section précédente, nous avons récupéré la liste de tous les
éléments utilisables pour composer la machine virtuelle. Une fois que
vous avez choisi les différents éléments de votre machine virtuelle,
elle peut être instanciée à l'aide de la commande
`openstack server create`. Par exemple, si nous souhaitons lancer une
image Centos 7 avec 1 cpu, 2 Go de RAM et 20 Go de disque dur sur le
réseau `project_network` et dont le nom sera *MY\_VM\_NAME*, nous
utiliserons la commande suivante :
``` {.sourceCode .console}
$ openstack server create --key-name cloudkey --image CentOS-7 \
--flavor 1CPU_2GB-RAM --nic net-id=project_network MY_VM_NAME
+-----------------------------+-----------------------------------------------------+
| Field | Value |
+-----------------------------+-----------------------------------------------------+
| OS-DCF:diskConfig | MANUAL |
| OS-EXT-AZ:availability_zone | |
| OS-EXT-STS:power_state | NOSTATE |
| OS-EXT-STS:task_state | scheduling |
| OS-EXT-STS:vm_state | building |
| OS-SRV-USG:launched_at | None |
| OS-SRV-USG:terminated_at | None |
| accessIPv4 | |
| accessIPv6 | |
| addresses | |
| adminPass | Ifld090KDjke |
| config_drive | |
| created | 2018-10-22T15:43:01Z |
| flavor | 1CPU_2GB-RAM (1244c110-32cc-41ef-b687-bf2111988963) |
| hostId | |
| id | 3623d900-f898-4d45-831a-4c6afb85aa1e |
| image | CentOS-7 (3abfbd5d-e07b-4187-b2d2-c58a51bf86b6) |
| key_name | cloudkey |
| name | MY_VM_NAME |
| progress | 0 |
| project_id | 59d0e58b2f3e488baed2360bc1767417 |
| properties | |
| security_groups | name='default' |
| status | BUILD |
| updated | 2018-10-22T15:43:01Z |
| user_id | 173a656c36a94a12ab8ba2473b9ceff3 |
| volumes_attached | |
+-----------------------------+-----------------------------------------------------+
```
>**note**
>Lors du lancement de machines virtuelles, vous pouvez vous retrouver
>confronté à des problèmes de dépassement de quota :
>``` {.sourceCode .console}
>$ openstack server create [...] MY_VM_NAME
>ERROR: Quota exceeded for cores: Requested 1, but already used 22 of 22 cores
>(HTTP 413) (Request-ID: req-6aefedba-4666-4393-b6a1-24423f3bef78)
>```
>Dans cet exemple, l'erreur vous indique que tous les processeurs
>disponibles pour votre groupe (*project*) sont actuellement occupés.
>Vous pouvez soit attendre que d'autres utilisateurs en libèrent, ou
>alors demander aux administrateur du service de vous attribuer un
>quota supplémentaire.
>
>Vous pouvez consulter les limites de quota grâce à la commande
>suivante :
>
>``` {.sourceCode .console}
>$ openstack quota show
>+----------------------+----------------------------------+
>| Field | Value |
>+----------------------+----------------------------------+
>| backup-gigabytes | 1000 |
>| backups | 10 |
>| cores | 20 |
>| fixed-ips | -1 |
>| floating-ips | 50 |
>| gigabytes | 1000 |
>| health_monitors | None |
>| injected-file-size | 10240 |
>| injected-files | 5 |
>| injected-path-size | 255 |
>| instances | 10 |
>| key-pairs | 100 |
>| l7_policies | None |
>| listeners | None |
>| load_balancers | None |
>| location | None |
>| name | None |
>| networks | 10 |
>| per-volume-gigabytes | -1 |
>| pools | None |
>| ports | 50 |
>| project | 59d0e58b2f3e488baed2360bc1767417 |
>| project_id | None |
>| properties | 128 |
>| ram | 51200 |
>| rbac_policies | 10 |
>| routers | 10 |
>| secgroup-rules | 100 |
>| secgroups | 10 |
>| server-group-members | 10 |
>| server-groups | 10 |
>| snapshots | 10 |
>| subnet_pools | -1 |
>| subnets | 10 |
>| volumes | 10 |
>+----------------------+----------------------------------+
>```
L'aide en ligne est disponible et décrit tous les paramètres utilisables :
``` {.sourceCode .console}
$ openstack help server create
usage: openstack server create [-h] [-f {json,shell,table,value,yaml}]
[-c COLUMN] [--max-width <integer>]
[--fit-width] [--print-empty] [--noindent]
[--prefix PREFIX]
(--image <image> | --volume <volume>) --flavor
<flavor> [--security-group <security-group>]
[--key-name <key-name>]
[--property <key=value>]
[--file <dest-filename=source-filename>]
[--user-data <user-data>]
[--availability-zone <zone-name>]
[--block-device-mapping <dev-name=mapping>]
[--nic <net-id=net-uuid,v4-fixed-ip=ip-addr,v6-fixed-ip=ip-addr,port-id=port-uuid,auto,none>]
[--network <network>] [--port <port>]
[--hint <key=value>]
[--config-drive <config-drive-volume>|True]
[--min <count>] [--max <count>] [--wait]
<server-name>
Create a new server
[...]
```
> **note**
>
> Lors de l'utilisation de la commande `openstack`, il est possible
> d'utiliser aussi bien les noms (par exemple *MY\_VM\_NAME*) que les
> identifiants (par exemple `3623d900-f898-4d45-831a-4c6afb85aa1e`). Il
> est recommandé d'utiliser les identifiants, car ils sont uniques (il
> est possible de lancer deux machines virtuelles avec le même nom).
Avec la commande suivante, il est possible de suivre l'état de la VM :
``` {.sourceCode .console}
$ openstack server show MY_VM_NAME
+-----------------------------+----------------------------------------------------------+
| Field | Value |
+-----------------------------+----------------------------------------------------------+
| OS-DCF:diskConfig | MANUAL |
| OS-EXT-AZ:availability_zone | nova |
| OS-EXT-STS:power_state | Running |
| OS-EXT-STS:task_state | None |
| OS-EXT-STS:vm_state | active |
| OS-SRV-USG:launched_at | 2018-10-22T15:44:10.000000 |
| OS-SRV-USG:terminated_at | None |
| accessIPv4 | |
| accessIPv6 | |
| addresses | atlas_network=192.168.2.12 |
| config_drive | |
| created | 2018-10-22T15:43:01Z |
| flavor | 1CPU_2GB-RAM (1244c110-32cc-41ef-b687-bf2111988963) |
| hostId | 4011c6f57790dd40dc4be5c1121c45a2789d9c6f9fcee3ef8128a630 |
| id | 3623d900-f898-4d45-831a-4c6afb85aa1e |
| image | CentOS-7 (3abfbd5d-e07b-4187-b2d2-c58a51bf86b6) |
| key_name | cloudkey |
| name | MY_VM_NAME |
| progress | 0 |
| project_id | 59d0e58b2f3e488baed2360bc1767417 |
| properties | |
| security_groups | name='default' |
| status | ACTIVE |
| updated | 2018-10-22T15:44:10Z |
| user_id | 173a656c36a94a12ab8ba2473b9ceff3 |
| volumes_attached | |
+-----------------------------+----------------------------------------------------------+
```
Le status *ACTIVE* nous indique que la VM est prête à être utilisée.
Toutefois, elle ne possède pas d'interface vers le réseau
externe (public), puisque son adresse IP est dans le réseau interne. Avant de
pouvoir s'y connecter par SSH, il faut se connecter en premier lieu sur la passerelle puis
faire un SSH vers la VM en exécutant la commande suivante :
``` {.sourceCode .console}
$ ssh OS_LOGIN@IP_MY_VM
```
où l'identifiant *OS_LOGIN* peut prendre par exemple les valeurs *debian*, *ubuntu* ou *centos*
suivant l'image utilisée. Par exemple, pour une VM créée à partir d'une image `debian` et ayant
pour adresse l'IP *192.168.245.5*, il suffit de taper :
``` {.sourceCode .console}
$ ssh debian@192.168.245.5
```
Les identifiants de connexions pour les images les plus fréquemment utilisées sont disponibles sur [la
page](https://docs.openstack.org/image-guide/obtain-images.html) de la documentation officielle d'`Openstack`.
>**note**
> Pour se connecter directement à la VM, il est possible de faire un tunnel SSH en rajoutant
> dans le fichier `~/.ssh/config` les instructions suivantes :
>``` {.sourceCode .console}
> Host MY_VM_NAME
> User OS_LOGIN
> Hostname IP_MY_VM
> ForwardAgent yes
> ProxyCommand ssh -XW %h:%p USER_NAME@IP_PROJECT_SSHGATE
>```
> Noter qu'ici `MY_VM_NAME` peut prendre n'importe quel nom. Pour se connecter à la VM,
> il suffit de faire :
>``` {.sourceCode .console}
> $ ssh MY_VM_NAME
>```
Personnalisation des machines virtuelles
----------------------------------------
Vous pouvez personnaliser vos machines virtuelles lors de leur démarrage
initial grâce au paramètre `--user-data` de `openstack server create`.
Ainsi, pour exécuter *script.sh* (dans l'exemple) lors du démarrage de votre machine virtuelle,
il suffit de taper :
``` {.sourceCode .console}
$ openstack server create [...] --user-data ./script.sh MY_VM_NAME
```
Gestion du stockage
-------------------
Par défaut, lorsqu'une machine virtuelle est détruite, tous les
changements que vous avez pu y apporter disparaissent. Pour pouvoir
stocker des données réutilisables entre plusieurs sessions, il est
nécessaire de créer des disques permanents. Pour afficher la liste de
vos disques, utilisez :
``` {.sourceCode .console}
$ openstack volume list
+--------------------------------------+---------------+-----------+------+--------------------------------------------+
| ID | Display Name | Status | Size | Attached to |
+--------------------------------------+---------------+-----------+------+--------------------------------------------+
| d874ed50-f4dd-11e6-b99e-8f36e05a44c6 | MONGODB | in-use | 100 | Attached to DATA_ANALYSIS on /dev/vdd |
| e3469d32-f4dd-11e6-b9be-3b36b57652e5 | DATA_1 | in-use | 200 | Attached to DATA_ANALYSIS on /dev/vdc |
| ec8de7c4-f4dd-11e6-a96b-7f9e7042f1e8 | chemistry-vol | available | 200 | |
| 0243cb42-f4de-11e6-9d72-b73ff56f8215 | VM_IPHC_START | available | 10 | |
| 09c16c44-f4de-11e6-8b45-433e4aa51e4c | SIMDAT_VOLUME | available | 8 | |
| 0e48a656-f4de-11e6-878b-eb0c0efe4cca | vmdata_disk_2 | available | 250 | |
| 13c86eae-f4de-11e6-b316-1f8b7ed3376e | DATA_DISK | in-use | 50 | Attached to DATA_ANALYSIS on /dev/vdb |
| 179a0326-f4de-11e6-920c-c7f2b28ed02b | R_Data | in-use | 8 | Attached to vm_iphc_r_analysis on /dev/vdb |
+--------------------------------------+---------------+-----------+------+--------------------------------------------+
```
Pour créer un nouvel espace de stockage persistant (nommé
*MY\_VOLUME\_NAME* et d'une taille de 8 Go), exécutez :
``` {.sourceCode .console}
$ openstack volume create --size 8 MY_VOLUME_NAME
+---------------------+--------------------------------------+
| Field | Value |
+---------------------+--------------------------------------+
| attachments | [] |
| availability_zone | nova |
| bootable | false |
| consistencygroup_id | None |
| created_at | 2017-02-16T10:08:02.493311 |
| description | None |
| encrypted | False |
| id | 58230433-086f-4ff2-99ac-8c3e0f5520c2 |
| multiattach | False |
| name | MY_VOLUME_NAME |
| properties | |
| replication_status | disabled |
| size | 8 |
| snapshot_id | None |
| source_volid | None |
| status | creating |
| type | None |
| updated_at | None |
| user_id | c13c93bf1b79447c8cd1464128d7685f |
+---------------------+--------------------------------------+
```
Pour attacher ce nouveau volume à la machine virtuelle à l'aide de son
identifiant, utilisez la commande :
``` {.sourceCode .console}
$ openstack server add volume --device /dev/vdb MY_VM_NAME 58230433-086f-4ff2-99ac-8c3e0f5520c2
```
Le stockage sera mis à disposition par le système d'exploitation en tant
que `/dev/vdb`. Pour vérifier que le disque est bien associé, vérifiez
que la colonne `Status` à pour valeur *in-use* et que la colonne
`Attached to` contient bien l'identifiant de la VM :
``` {.sourceCode .console}
$ openstack volume list --name MY_VOLUME_NAME
+--------------------------------------+----------------+--------+------+------------------------------------+
| ID | Display Name | Status | Size | Attached to |
+--------------------------------------+----------------+--------+------+------------------------------------+
| 58230433-086f-4ff2-99ac-8c3e0f5520c2 | MY_VOLUME_NAME | in-use | 8 | Attached to MY_VM_NAME on /dev/vdb |
+--------------------------------------+-------------------------+------+------------------------------------+
```
Au départ, ce disque ne contient aucune donnée et n'est pas formaté. Si
ce disque est destiné à contenir des données confidentielles, nous vous
recommandons de le chiffrer. Cette opération est détaillée dans le
chapitre [Chiffrage des disques permanents](#disk-encryption). Dans le
cas contraire, connectez-vous à votre VM pour formater ce disque et le
monter :
``` {.sourceCode .console}
[centos@my-vm-name ~]$ sudo su
[root@my-vm-name centos]# mkfs -t ext4 /dev/vdb
[root@my-vm-name centos]# mkdir /storage1
[root@my-vm-name centos]# mount /dev/vdb /storage1
[root@my-vm-name centos]# df -h /storage1
Filesystem Size Used Avail Use% Mounted on
/dev/vdb 8.0G 3.0M 7.8G 1% /storage1
```
La dernière commande permet de vérifier que nous avons bien l'espace
disponible de la taille choisie (ici 8 Go) monté sur `/storage1`.
> **note**
>
> Le disque virtuel peut également être partitionné avant le formatage.
> Pour ce faire, référez-vous à la documentation du système
> d'exploitation choisi.
Vous pouvez le déplacer d'une machine virtuelle à une autre en le
démontant au sein de la VM (pour garantir l'intégrité des données
stockées sur ce disque) :
``` {.sourceCode .console}
[root@my-vm-name centos]# umount /storage1
```
> **note**
>
> Si vous avez ajouté votre volume persistant dans le fichier
> `/etc/fstab` de votre machine virtuelle (c.f. plus bas), pensez à
> supprimer la ligne en question avant de démonter le disque virtuel
> sous peine de ne plus pouvoir démarrer votre VM.
Puis en détachant le disque à l'aide des commandes :
``` {.sourceCode .console}
$ openstack server remove volume MY_VM_NAME 58230433-086f-4ff2-99ac-8c3e0f5520c2
$ openstack volume list --name MY_VOLUME_NAME
+--------------------------------------+----------------+-----------+------+-------------+
| ID | Display Name | Status | Size | Attached to |
+--------------------------------------+----------------+-----------+------+-------------+
| 58230433-086f-4ff2-99ac-8c3e0f5520c2 | MY_VOLUME_NAME | available | 8 | |
+--------------------------------------+----------------------------+------+-------------+
```
> **note**
>
> Lorsque la machine virtuelle est redémarrée, le disque n'est pas monté
> automatiquement au système de fichier. Pour monter le disque
> automatiquement, il faut ajouter une entrée dans le fichier
> `/etc/fstab`.
Fin d'une machine virtuelle
---------------------------
Une fois les tâches sur la VM terminées, elle peut être arrêtée pour
être redémarrée plus tard :
``` {.sourceCode .console}
$ openstack server stop MY_VM_NAME
$ openstack server start MY_VM_NAME
```
Afin de libérer les ressources, la VM peut également être supprimée.
Dans ce cas, toutes les modifications qui ont été apportées à l'image
(installation de paquets, ...) seront perdues, hormis celles qui sont
sur le disque persistant. Avant de supprimer la VM, il faut se connecter
à la VM et démonter le disque persistant (pour éviter de corrompre les
données) :
``` {.sourceCode .console}
[root@my-vm-name centos]# umount /storage1
```
Si vous n'avez plus besoin des données sur le disque persistant, il faut
le réinitialiser avec des données aléatoires pour des raisons de
confidentialité (cette opération peut être assez longue) :
``` {.sourceCode .console}
[root@my-vm-name centos]# dd if=/dev/urandom of=/dev/vdb bs=4k
```
Puis, une fois la suppression des données effectives, détacher et
supprimer le volume avec :
``` {.sourceCode .console}
$ openstack server remove volume MY_VM_NAME 58230433-086f-4ff2-99ac-8c3e0f5520c2
$ openstack volume delete 58230433-086f-4ff2-99ac-8c3e0f5520c2
```
Enfin, vous pouvez supprimer la VM :
``` {.sourceCode .console}
$ openstack server delete MY_VM_NAME
```
Utilisation avancée
===================
Ce chapitre décrit des possibilités d'utilisation avancée du service de
Cloud Computing IaaS.
Chiffrage des disques permanents
--------------------------------
Cette section détaille l'utilisation de [l'outil
dm-crypt/LUKS](https://gitlab.com/cryptsetup/cryptsetup) pour le
chiffrage des disques permanents. Cet outil est fourni en standard par
les distributions Linux et peut facilement être installé avec le
gestionnaire de paquets dans votre machine virtuelle. L'exemple se base
sur l'utilisation d'une distribution Ubuntu, mais peut facilement être
réalisé avec une distribution RedHat.
``` {.sourceCode .console}
ubuntu@my-vm-name:~$ sudo su -
sudo: unable to resolve host my-vm-name
root@my-vm-name:~# apt -y update
root@my-vm-name:~# apt -y install cryptsetup
```
Pour chiffrer un disque permanent, il faut tout d'abord l'initialiser
correctement. Dans l'exemple ci-dessous, le disque dénommé `/dev/vdb`
est dans un premier temps rempli de données aléatoires, puis il est
initialisé à l'aide de la commande `cryptsetup luksFormat` ci-dessous.
Cette première étape peut être assez longue.
``` {.sourceCode .console}
root@my-vm-name:~# dd if=/dev/urandom of=/dev/vdb bs=4k
root@my-vm-name:~# cryptsetup -v --cipher aes-xts-plain64 --key-size 512 --hash sha512 \
--iter-time 5000 --use-random luksFormat /dev/vdb
```
Si cette dernière commande ralentit, voire bloque avec le message
suivant :
``` {.sourceCode .console}
System is out of entropy while generating volume key.
Please move mouse or type some text in another window to gather some random events.
Generating key (0% done).
```
Alors vous pouvez rendre la commande `cryptsetup [...] luksFormat` plus
rapide en installant préalablement le programme `haveged` dans votre
machine virtuelle.
La commande suivante permet de vérifier que le disque est maintenant du
type LUKS :
``` {.sourceCode .console}
root@my-vm-name:~# cryptsetup luksDump /dev/vdb
LUKS header information for /dev/vdb
Version: 1
Cipher name: aes
Cipher mode: xts-plain64
Hash spec: sha512
Payload offset: 4096
MK bits: 512
MK digest: c4 f7 4b 02 2a 3f 12 c1 2c ba e5 c9 d2 45 9a cd 89 20 6c 73
MK salt: 98 58 3e f3 f6 88 99 ea 2a f3 cf 71 a0 0d e5 8b
d5 76 64 cb d2 5c 9b d1 8a d3 1d 18 0e 04 7a eb
MK iterations: 81250
UUID: c216d954-199e-4eab-a167-a3587bd41cb3
Key Slot 0: ENABLED
Iterations: 323227
Salt: a0 45 3e 98 fa cf 60 74 c6 09 3d 54 97 89 be 65
5b 96 7c 1c 39 26 47 b4 8b 0e c1 3a c9 94 83 c2
Key material offset: 8
AF stripes: 4000
Key Slot 1: DISABLED
Key Slot 2: DISABLED
Key Slot 3: DISABLED
Key Slot 4: DISABLED
Key Slot 5: DISABLED
Key Slot 6: DISABLED
Key Slot 7: DISABLED
```
Le disque est maintenant prêt à être utilisé. La première fois que vous
l'utilisez, il faut effectuer les étapes suivantes :
1. Ouvrir le disque chiffré avec la commande `cryptsetup luksOpen`. Le
nom *storage1* n'est qu'indicatif, vous pouvez choisir ce que vous
voulez :
``` {.sourceCode .console}
root@my-vm-name:~# cryptsetup luksOpen /dev/vdb storage1
```
2. Créer un système de fichier sur le disque :
``` {.sourceCode .console}
root@my-vm-name:~# mkfs.ext4 /dev/mapper/storage1
```
3. Créer le point de montage du disque :
``` {.sourceCode .console}
root@my-vm-name:~# mkdir /storage1
```
4. Monter le disque :
``` {.sourceCode .console}
root@my-vm-name:~# mount -t ext4 /dev/mapper/storage1 /storage1
```
5. Vérifier l'espace disponible (cela peut être légèrement différent de
ce qui a été entré lors de la commande `openstack volume create`) :
``` {.sourceCode .console}
root@my-vm-name:~# df -h /storage1
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/storage1 2.0G 6.0M 1.9G 1% /storage1
```
Une fois que le disque est opérationnel, les étapes 2 et 3 ne sont plus
nécessaires.
Vous pouvez maintenant envoyer des fichiers (par exemple DONNEES.dat)
depuis votre ordinateur personnel dans votre machine virtuelle de façon
sécurisée si vous avez configuré le tunnel ssh comme expliqué dans la dernière note de la partie
[Lancement de la machine virtuelle ( VM )](#Lancementdelamachinevirtuelle), par exemple avec `scp` :
``` {.sourceCode .console}
$ scp DONNEES.dat MY_VM_NAME:/le/chemin/destination
DONNEES.dat 100% 82 0.1KB/s 00:00
```
Lorsque vous avez terminé votre travail sur le disque, vous pouvez le
retirer proprement avec les commandes suivantes :
``` {.sourceCode .console}
root@my-vm-name:~# umount /storage1
root@my-vm-name:~# cryptsetup close storage1
```
Pour les utilisations suivantes du disque virtuel persistant, il n'y
aura pas besoin d'effectuer toutes ces opérations, seules les suivantes
sont nécéssaires :
``` {.sourceCode .console}
root@my-vm-name:~# cryptsetup luksOpen /dev/vdb storage1
root@my-vm-name:~# mkdir /storage1
root@my-vm-name:~# mount -t ext4 /dev/mapper/storage1 /storage1
```
Résolution des problèmes
========================
Cette section vous permet de résoudre les problèmes les plus communs
rencontrés lors de l'utilisation de OpenStack.
Erreur de connexion avec SSH
----------------------------
Immédiatement après le démarrage de la machine virtuelle, vous pouvez
vous retrouver avec des problèmes de connection :
``` {.sourceCode .console}
$ ssh debian@192.168.245.5
ssh: connect to host 192.168.245.5 port 22: Connection refused
```
Ce problème est généralement dû au fait que le service SSH n'est pas
encore démarré sur la machine virtuelle. Il faut attendre, cela pouvant
prendre jusqu'à plusieurs minutes.
Un autre type d'erreur peut être rencontré :
``` {.sourceCode .console}
$ ssh debian@192.168.245.5
[...]
Permission denied (publickey).
```
Dans ce cas, il faut vérifier que la clé SSH que vous utilisez est la
même que celle stockée dans la base de données OpenStack. Pour cela,
vérifiez que leurs empreintes (*fingerprint*) sont équivalentes. Pour
obtenir l'empreinte de la clé stocké par OpenStack, exécutez :
``` {.sourceCode .console}
$ openstack keypair list
+----------+-------------------------------------------------+
| Name | Fingerprint |
+----------+-------------------------------------------------+
| cloudkey | 0d:97:13:66:49:03:44:da:69:82:3c:dd:b9:d7:25:64 |
+----------+-------------------------------------------------+
```
Et pour obtenir l'empreinte de la clé utilisé par la commande `ssh`,
exécutez :
``` {.sourceCode .console}
$ ssh-keygen -lf ${HOME}/.ssh/id_rsa.pub
2048 33:91:4b:38:52:63:1d:18:7b:e0:e3:0d:3b:63:ce:4b you@home (RSA)
```
Si elles sont différentes, il faut mettre à jour votre clé publique dans
OpenStack :
``` {.sourceCode .console}
$ openstack keypair delete cloudkey
$ openstack keypair add --pub-key=${HOME}/.ssh/id_rsa.pub cloudkey
$ openstack keypair list
+----------+-------------------------------------------------+
| Name | Fingerprint |
+----------+-------------------------------------------------+
| cloudkey | 33:91:4b:38:52:63:1d:18:7b:e0:e3:0d:3b:63:ce:4b |
+----------+-------------------------------------------------+
```
Si elles sont bien identiques, il se peut que OpenStack n'ait pas réussi
à les installer correctement lors du démarrage de la nouvelle VM. La
brique logicielle `cloud-init` est responsable de l'installation de la
clé SSH dans votre machine virtuelle. Vous pouvez voir les lignes de log
de cloud-init dans la console de la machine virtuelle. Pour obtenir
l'url de connexion à la console, utilisez la commande suivante :
``` {.sourceCode .console}
$ openstack console url show --novnc MY_VM_NAME
+-------+----------------------------------------------------------------------------------------------+
| Type | Url |
+-------+----------------------------------------------------------------------------------------------+
| novnc | http://lpnhe-cloud028.in2p3.fr:6080/vnc_auto.html?token=ef1768bd-a237-4845-af0e-7f58eb6aeb02 |
+-------+----------------------------------------------------------------------------------------------+
```
Puis, après vous être connecté à la console avec un navigateur Internet,
recherchez les lignes qui contiennent les éléments *ci-info* et
*Authorized keys from* et comparez les empreintes de votre clé. Si vous
voyez des messages d'erreur, le plus simple est de [contacter les
administrateurs](mailto:grid.admin@lpnhe.in2p3.fr) en leur
fournissant une copie de ces messages d'erreur.
Lorsque la clé est transférée avec succès sur la machine virtuelle, vous
avez un message du type :
``` {.sourceCode .console}
Cloud-init v. 0.7.5 running 'module:final' at Mon, 27 Jun 2015 08:15:34 +0000. Up 65.40 seconds.
ci-info: ++++++++++++++Authorized keys from /root/.ssh/authorized_keys for user root++++++++++++++
ci-info: +---------+-------------------------------------------------+---------+-----------------+
ci-info: | Keytype | Fingerprint (md5) | Options | Comment |
ci-info: +---------+-------------------------------------------------+---------+-----------------+
ci-info: | ssh-rsa | 33:91:4b:38:52:63:1d:18:7b:e0:e3:0d:3b:63:ce:4b | - | joe@hey.com |
ci-info: +---------+-------------------------------------------------+---------+-----------------+
```
Si vous souhaitez uniquement consulter la sortie console de la machine
virtuelle, il sera plus confortable d'utiliser :
``` {.sourceCode .console}
$ openstack console log show MY_VM_NAME
```
Documentation complémentaire
============================
Les sites suivants peuvent être consultés pour obtenir plus
d'informations concernant l'utilisation d'OpenStack :
- [guide d'utilisation du client
openstack](https://docs.openstack.org/python-openstackclient/latest/)
;
- [wiki officiel
d'OpenStack](https://wiki.openstack.org/wiki/Main_Page) ;
- [questions & réponses sur OpenStack](https://ask.openstack.org) ;
- [actualités sur le monde OpenStack](http://planet.openstack.org) ;