---
# System prepended metadata

title: Projet PIM

---

# Projet PIM

# PIM Virtual Cloud Management
**Auteurs :** ***Cedrigue DJIONGO, Daniel AFIVI, Oumar Barry, Eric et Ulrich***

[TOC]

Dans le cadre de Projet Inter-Matière, nous avons choisi de mettre en place un cloud virtuel destiné au DevOps. 

## Mise en place du cloud virtuel 

Nous commençons par la mise en place l'environnement matériels puis nous allons déployer les outils logiciels.

![](https://i.imgur.com/4rn3euc.png)

Nous utilisons l'hyperviseur VirtualBox, Ubuntu Server sur les noeuds Openstack et Ubuntu Desktop pour les accès clients.

* Nous avons besoins de 03 réseaux pour notre cloud :
    * Mgt Network      : 192.168.100.0/24 (Administration du cloud virtuel)
    * Internal Network : 192.168.150.0/24 (Communications des Services)
    * External Network : 192.168.190.0/24 (Accès client)
    * Reseau NAT       : 10.0.4.0/24      (Internet/VBox))
![](https://i.imgur.com/5MNzEsf.png)

* Nous avons les VM suivantes:
### **Controller Node :** 
01 CPU, 1Go RAM, 10Go HHD, OS Ubuntu Server 16.04, 03 Cartes réseaux (**NAT** pour Adapter 1, **Mgt Network** pour Adapter 2, **External Network** pour Adapter 3) 
        ![](https://i.imgur.com/3vd5jo9.png)
        
* Modifier le fichier `/etc/hosts` comme suit:
        ![](https://i.imgur.com/yzW0Lck.png)

* Modifier le fichier      `/etc/network/interfaces`
        ![](https://i.imgur.com/e06MjWb.png)
        `sudio systemctl restart networking`
        
* Mise à jour des dépots et des paquets installés: 
        `sudo apt update -y && sudo apt upgrade -y `
* Installation du serveur de temps NTP pour l'horodatage et les synchronisations : 
        `sudo apt install ntp -y`
    * **Configurer du serveur NTP en modifiant le fichier**       `/etc/ntp.conf` 
    ![](https://i.imgur.com/KD44msn.png) 
        `sudo systemctl restart ntp && sudo ntpq -p`
    * **Installation du SGBD Mysql**
         ```
         sudo apt install python3-mysqldb mysql-server -y 
         sudo nano -l /etc/mysql/mysql.conf.d/mysqld.cnf
         ```
        ![](https://i.imgur.com/hAdiCzp.png)

    * **Installation et configurationde RabbitMQ Server** 
        `curl -fsSL https://github.com/rabbitmq/signing keys/releases/download/2.0/rabbitmq-release-signing-key.asc | sudo apt-key add -` 
        `sudo apt-get install apt-transport-https -y` 
        `sudo apt-get install rabbitmq-server -y --fix-missing`
        `sudo rabbitmq-plugins enable rabbitmq_management`
        `http://controller:15672/` 
        `sudo rabbitmqctl add_user openstack openstack` 
        `sudo rabbitmqctl set_user_tags openstack administrator`
      
    * **Installation et configuration du service Keystone**
                        
        * Installation : `sudo apt install keystone python3-openstackclient`
            
        * Configuration 
    ```
    sudo su -
    sudo nano -l /etc/keystone/keystone.conf 
    ``` 
    ![](https://i.imgur.com/ha9IhPm.png)

    ![](https://i.imgur.com/MuKFxEw.png)
            
        `sudo rm /var/lib/keystone/ keystone.db` 
            
    * **Creation de la base de donnée et de l'utilisateur pour Keystone**
            ```
            sudo mysql 
            CREATE DATABASE keystone;
            GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'localhost' IDENTIFIED BY 'openstack';
            GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'%' IDENTIFIED BY 'openstack';             
            FLUSH PRIVILEGES;
            exit;
            ```
             
    * Création des tables de la base de données *keystone*
                ` sudo -s /bin/sh -c  "keystone-manage db_sync" keystone`
                ![](https://i.imgur.com/z8UXN40.png)

    * Génération d'un token de service (via OpenSSL)
             ```
             openssl
             rand -hex 10
             exit
             ```
    * Copie du Token génénré dans le fichier /etc/keystone/keystone.conf
             ![](https://i.imgur.com/ZpH490r.png)
              `systemctl restart keystone`
             
    * Création des utilisateurs, des tenants et de roles 
        ```
        export OS_SERVICE_TOKEN=5613d2b8d46d8bb5859d
        export OS_SERVICE_ENDPOINT=http://controller:35357/v2.0
        keystone user-create --name=openstack --pass=openstack --email=adkot@estiam.com           

        ```
        ![](https://i.imgur.com/YetMlEP.png)
        ```
        keystone role-create --name=adminRole
        ``` 
        ![](https://i.imgur.com/RPPHGjv.png)
        ```
        keystone tenant-create --name=pimTenant --descriptio="PIM Tenant"

        ```
        ![](https://i.imgur.com/bBG7mJ8.png)
        ```
        keystone user-role-add --user=openstack --tenant=pimTenant --role=adminRole
        ```
    * Creation d'un services
        ```
        keystone service-create --name=keystone --type=identity --description="Openstack Identity"            
        ```
        ![](https://i.imgur.com/FiHmVtG.png)
            
    * Ajout d'un API Endpoint au service créé
        ```
        keystone endpoint-create --service-id=$(keystone service-list | awk '/ identity / {print$2}') --publicurl=http://controller:5000/v2.0 --internalurl=http://controller:5000/v2.0 --admin=http://controller:35357/v2.0 0
        ```
        ![](https://i.imgur.com/xgaRaLO.png)

    * Mise en place de neutron

        * Créer la base de donnée nommée neutron et un utilisateur nommée neutron ayant tout les droits sur cette base de données
        * Créer un utilisateur dans keystone pour ce service
        ```
        sudo keystone user-create --name neutron --pass openstanck --email pim@estiam.com
        keystone user-role-add --user neutron --tenant service --role openstack
        keystone service-create --name neutron --type network --description "Openstack Networking"
        keystone endpoint-create --service-id $(keystone service-list | awk '/ network / {print $2}') --publicurl http://controller:9696 --adminurl http://controller:9696 --internalurl http://controller:9696
        sudo apt install neutron-server neutron-plugin-ml2 -y
        ```
                 
        * Ouvrir le fichier et modifier les lignes suivantes:
        ```
        connection = mysql://neutron:openstack@controller/neutron
        auth_strategy = keystone
        rpc_backend     = neutron.openstack.common.rpc.impl_kombu
        rabbit_host     = controller
        rabbit_password = openstack
                 
        [keystone_authtoken]
        auth_host = controller
        auth_port = 35357
        auth_protocol = http
        admin_tenant_name = a8bb88b2929c419c92a8a136db0b1dc7
        admin_user = neutron
        admin_password = openstack
        #signing_dir = $state_path/keystone-signing
        auth_url = http://controller:5000
        ```
                    
        * Ouvrir et configurer le fichier  `/etc/neutron/plugins/ml2/ml2_conf`
        ```
        [ml2]
        type_drivers = gre
        tenant_networks_types = gre
        mechanism_drivers = openvswitch
        
        [ml2_type_gre]
        tunnel_id_ranges = 1:1000
                    
        [securitygroup]
        firewall_driver = neutron.agent.linux.iptables_firewall.OVSHybridIptables$
         enable_security_group = true
        ```

### **Network Node**    
* Caractéristique de la machine: 01 CPU, 1Go RAM, 05Go HHD ![](https://i.imgur.com/y5jQJa3.png)
* Modifier le fichier `/etc/hosts` comme suit:
    ![](https://i.imgur.com/yzW0Lck.png)

* Modifier le fichier `/etc/netplan/00-installer-config.yaml`
    ![](https://i.imgur.com/INVJDK9.png)
    `sudo apt update -y && sudo apt upgrade -y `
* Installation du serveur de temps NTP pour l'horodatage et les synchronisations : `sudo apt install ntp -y`
* Configurer du client NTP  `/etc/ntp.conf` ![](https://i.imgur.com/vYzUZ7r.png) `sudo systemctl restart ntp` `ntpq -c peers` ![](https://i.imgur.com/AHGsQGh.png)
* Installation du connecteur pyhton pour le SGBD Mysql `sudo apt install python3-mysqldb -y`

### **Compute Node**    : 01 CPU, 1Go RAM, 10Go HHD![](https://i.imgur.com/EXcMCjc.png)
* Modifier le fichier `/etc/hosts` comme suit:
    ![](https://i.imgur.com/yzW0Lck.png)

* Modifier le fichier `/etc/netplan/00-installer-config.yaml`
        ![](https://i.imgur.com/tcEvBb7.png)
     `sudo apt update -y && sudo apt upgrade -y `
*  Installation du serveur de temps NTP pour l'horodatage et les synchronisations : `sudo apt install ntp -y`
* Configurer du client NTP  `/etc/ntp.conf` ![](https://i.imgur.com/vYzUZ7r.png) `sudo systemctl restart ntp` `ntpq -c peers`![](https://i.imgur.com/bFmIuiN.png)
* Installation du connecteur pyhton pour le SGBD Mysql `sudo apt install python3-mysqldb -y`



### **Storage Node : CINDER**    : 01 CPU, 1Go RAM, 20Go HHD
* La mise en place de ce noeud s'appuie sur les ressources précedement déployé et fonctionnelles comme Keystone
* Installation des logiciels d'administration sur le noeuds controller
     ` sudo apt install cinder-api cinder-scheduler -y`
* Modifier le fichier de configuration ` sudo nano /etc/cinder/cinder.conf` ![](https://i.imgur.com/TlBcLEZ.png)

* Créer la base de données cinder ainsi que l'utilisateur cinder qui aura tout les droits sur cette base de données
```
create database cinder;
grant all privileges on cinder.* to 'cinder'@'localhost' identified by 'openstack';
grant all privileges on cinder.* to 'cinder'@'%' identified by 'openstack'
su -s /bin/sh -c "cinder-manage db sync" cinder
keystone user-create --name=cinder --pass openstack --email cinder@estiam.com
keystone user-role-add --user cinder --tenant service --role admin
keystone service-create --name cinder --type volume --description "Openstack Block Storage"
keystone endpoint-create --service-id $(keystone service-list | awk '/ volume / {print $2}') --publicurl http://controller:8776/v1/%\(tenant_id\)s --adminurl http://controller:8776/v1/%\(tenant_id\)s --internalurl http://controller:8776/v1/%\(tenant_id\)s
```
![](https://i.imgur.com/wGQuz2e.png)
![](https://i.imgur.com/KB3i0ht.png)

* Nous avons créé un autre espace de stockage de type bloc
![](https://i.imgur.com/qM272jF.png)
```
keystone endpoint-create --service-id $(keystone service-list | awk '/ volume2 / {print $2}') --publicurl http://controller:8776/v2/%\(tenant_id\)s --adminurl http://controller:8776/v2/%\(tenant_id\)s --internalurl http://controller:8776/v2/%\(tenant_id\)s
```
* Relancer les services cinder-api et cinder-scheduler
            ```
                systemctl enable cinder-api
                systemctl enable cinder-scheduler
                systemctl restart cinder-api
                systemctl restart cinder-scheduler
            ```
* Configuration et administration du noeud cinder
    * Installation des paquets:`sudo apt install lvm2 cinder-api tgt targetcli-fb -y`
    * Visualisation des périphériques de stockage :
                `lshw -C disk` ![](https://i.imgur.com/vKJYHrE.png) 
    * Initialisation de la partition LVM : `pvcreate /dev/sdb`
    * Création des volumes logiques : `vgcreate cinder-volume /dev/sdb`
    * Modifier le fichier de configuration retirant le commentaire sur cette ligne: ` filter = [ "a|.*|" ]`
       * Installer le paquets: cinder-volume :`sudo apt install cinder-volume -y` et modifier le fichier de configuration `/etc/cinder/cinder.conf` ![](https://i.imgur.com/dZBqy5U.png)`systemctl restart cinder-volume`




## Description des services utilisés

### I- Keystone

Keystone est le service d'authentification d'Openstack. Il s'agit du point d'entrée d'Openstack car tous les autres services (glance, nova, cinder, neutron ...) reposent sur lui pour autoriser l'accès aux ressources. 
Keystone ne gère pas seulement l'authentification, mais aussi l'autorisation d'accès aux différentes fonctionnalités des différents services d'Openstack et aussi le catalogue des services.

#### 1- Authentification

L'authentification dans Openstack peut être faite faite sur la base de plusieurs sources de confiance. Il s'agit de :

- Base de données interne de Openstack : les identifiants sont stockés directement dans une base de données interne à Openstack et l'authentification et l'autorisation se font à partir de ces données.
- LDAP: Openstack peut utiliser des services d'annuaire LDAP comme source d'authentification.


#### 2- Service de catalogue

Le service d'identité (Keystone) permet aux utilisateurs et aux services de retrouver les autres services d'Openstack en se basant sur le catalogue de service. 
En effet, les services disposent de plusieurs points de terminaisons API qui permettent d'utiliser plus efficacement les services Openstack. Certains de ces services sont accessibles publiquement et d'autres non. 
Keystone permet de créer un point d'entrée pour chaque service avec les points de terminaison correspondant et les sécurise en fonction des règles d'administration déclarées.

#### 3- Installation de Keystone
Pour installer Keystone, il faut certains préréquis. Une fois ces prérequis installés, nous passerons à l'installation de Keystone.
##### a- Prérequis
- Création de la base de données utiisée par Keystone : 
Il faut executer dans l'ordre les commandes suivantes:
```
mysql
CREATE DATABASE keystone;
```
- Configuration de la base de données : 
Il faudra peupler la base de données avec les tables et accorder les droits nécessaires:
`    GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'localhost' IDENTIFIED BY 'KEYSTONE_DBPASS';`
    `GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'%' IDENTIFIED BY 'KEYSTONE_DBPASS';`

Il faudra modifier le mot de passe du user keystone (KEYSTONE_DBPASS) par le mot de passe de votre choix
Les prérequis étant installés, nous allons passer à l'installation du service Keystone

##### b- Installation du service

Pour mettre à disposition ce service, il faut l'installer via le gestionnaire de paquet de votr distribution. Sous Ubuntu, nous aurons :  `apt install keystone`
Ensuite, il faudra éditer le fichier /etc/keystone/keystone.conf et effectuer les modifications suivantes :

    Dans la section [database], configurez l’accès à la base de données :

    [database]
    # ...
    connection = mysql+pymysql://keystone:KEYSTONE_DBPASS@controller/keystone

    Remplacer KEYSTONE_DBPASS par le mot de passe choisi pour la base de données.
    
Dans la section [token], configurer le fournisseur de token Fernet :

```
    [token]
    # ...
    provider = fernet
```

Il faut ensuite peupler la base de données du service d’identité avec la commande 
``` su -s /bin/sh -c "keystone-manage db_sync" keystone ```

Initialiser le dépôt des clés Fernet :

```
keystone-manage fernet_setup --keystone-user keystone --keystone-group keystone
keystone-manage credential_setup --keystone-user keystone --keystone-group keystone
```

Bootstraper le service d’Identité:

  ```
keystone-manage bootstrap --bootstrap-password ADMIN_PASS \
  --bootstrap-admin-url http://controller:35357/v3/ \
  --bootstrap-internal-url http://controller:5000/v3/ \
  --bootstrap-public-url http://controller:5000/v3/ \
  --bootstrap-region-id RegionOne
```

Remplacer ADMIN_PASS par un mot de passe approprié pour un administrateur.

##### c- Mise à disposition du service aux utilisateurs et aux services

Pour permettre aux autres services et aux utilisateurs d'utiliser le service Keystone, nous devons l'exposer via le noeud controlleur de son API. Nous allons dans notre cas utiliser le serveur Web APACHE pour y arriver.
Nous allons pour celà éditer le fichier /etc/apache2/apache2.conf et configurer l’option ServerName pour pointer vers le nœud contrôleur :

    ServerName controller
    

##### d- Finalisation de l'installation

Redémarrer le service Apache et supprimer la base de données SQLite par défaut.

    `service apache2 restart`
    `rm -f /var/lib/keystone/keystone.db`

Configurer ensuite le compte administrateur

    $ export OS_USERNAME=admin
    $ export OS_PASSWORD=ADMIN_PASS
    $ export OS_PROJECT_NAME=admin
    $ export OS_USER_DOMAIN_NAME=Default
    $ export OS_PROJECT_DOMAIN_NAME=Default
    $ export OS_AUTH_URL=http://controller:35357/v3
    $ export OS_IDENTITY_API_VERSION=3

Remplacer ADMIN_PASS par le mot de passe utilisé dans la commande bootstrap keystone-manage de la section keystone-install-configure.


### II- Glance
Glance est le service d'image d'OpenStack. Il sert de base de données où sont stockées les images utilisées par les machines virtuelles. Il s'occupe ainsi de sauvegarder, de gérer et de mettre à disposition les images de systèmes d'ecploitation aux utilisateurs. Pour effectuer toute action sur Glance, il faut s'authentifier. 

Dans notre cas, nous avons développé un script qui permet de s'authentifier avec Keystone. Il nous génère donc un token que nous fournissons au service Image pour nous auhentifier.
Glance expose également comme l'ensemble des services Openstack des endpoints API qui permettent d'interagir avec les utilisateurs.

Passons maintenant à l'installation de Glance
#### a- Prérequis
Il faut initialiser la base de données que Glance utilisera. pour se faire, il faut s'authentifier puis executer les commandes suivantes:
```
 CREATE DATABASE glance;
 GRANT ALL PRIVILEGES ON glance.* TO 'glance'@'localhost' IDENTIFIED BY 'GLANCE_DBPASS';
 GRANT ALL PRIVILEGES ON glance.* TO 'glance'@'%' IDENTIFIED BY 'GLANCE_DBPASS';
```

Ensuite il faut sourcer les identifiants admin openstack sur le systeme en executant la commande ```. admin-openrc```
Nous allons ensuite créer un utilisateur openstack pour le service Glance en executant la commande:
```
openstack user create --domain default --password-prompt glance
```
Nous allons ensuite créer un projet pour le service Openstack en executant la commande: 
```
openstack role add --project service --user glance admin
```
 A présent nous allons mettre à disposition des différets types d'utilisateurs des endpoints API pour leur permettre d'interagir avec  Glance. Nous allons pour celà executer les commandes suivantes:
```
openstack endpoint create --region RegionOne image public http://controller:9292
openstack endpoint create --region RegionOne image internal http://controller:9292
openstack endpoint create --region RegionOne image admin http://controller:9292
```
#### b- Installation et configuration

Glance s'installe comme un paquet classique. Pour l'installer il faut utiliser le gestionnaire de paquet et executer la commande suivante : 
```
apt install glance
```
Une fois l'installation finir, il faut modifier les fichiers de configuration de Glance pour les adapter à nos besoins.
```
[database]
# ...
connection = mysql+pymysql://glance:GLANCE_DBPASS@controller/glance


[keystone_authtoken]
# ...
www_authenticate_uri = http://controller:5000
auth_url = http://controller:5000
memcached_servers = controller:11211
auth_type = password
project_domain_name = Default
user_domain_name = Default
project_name = service
username = glance
password = GLANCE_PASS

[paste_deploy]
# ...
flavor = keystone


[glance_store]
# ...
stores = file,http
default_store = file
filesystem_store_datadir = /var/lib/glance/images/

[oslo_limit]
auth_url = http://controller:5000
auth_type = password
user_domain_id = default
username = MY_SERVICE
system_scope = all
password = MY_PASSWORD
endpoint_id = ENDPOINT_ID
region_name = RegionOne

[DEFAULT]
use_keystone_quotas = True

```

NOus allons ensuite executer les commandes suivantes pour remplir la base de données de Glance : 
```
su -s /bin/sh -c "glance-manage db_sync" glance
``` 

Ensuite redemarrer le service avec la commande ```service glance-api restart```
### Fin de la partie pour Daniel


### Debut de la partie pour KONA

### Fin de la partie pour KONA

### Debut de la partie pour Urilch 

### Fin de la partie pour Urilch

## COMPUTE

![](https://i.imgur.com/mYkkdE6.png)

** La partie compute** d'OpenStack, Nova, permet de communiquer avec l'hyperviseur pour lancer et gérer les machines virtuelles.
Plusieurs types d'hyperviseurs sont actuellement disponibles tels que Xen, VMWare (ESX) et Hyper-V. Mais KVM est le mieux supporté par OpenStack. Nova est divisé en composants :

**Nova-api **: traite les requêtes API venant des clients ;
**Nova-compute** : daemon nova qui gère les VM ;
**Nova-scheduler** : coordonne le déploiement des VM sur les machines physiques ;
**Nova-conductor** : interlocuteur entre nova-compute et la base de données.

Dans une architecture classique, nova-compute peut être installé sur une ou plusieurs machines physiques.
Ces daemons communiquent entre eux via le bus de **message RabbitMQ**.
Toutes les demandes sont traitées par **nova-api** qui délègue ensuite la tâche à nova-compute. 
**Par exemple**, lors d'une demande de création d'instance (VM), **nova-api **fait une demande auprès de nova-scheduler afin de déterminer la machine hôte sur laquelle lancer l'instance (dépendant de sa taille et des disponibilités des serveurs physiques). La demande est ensuite transmise au nova-compute présent sur le
### Avant toute configuration lancer le fichier admin-openrc.sh
```
source admin-openrc.sh 
```

###  Création d'une instance
#### Généner une clé: 
Générer une paire de clés

La plupart des images cloud supportent l’authentification par clé publique plutôt que l’authentification classique par mot de passe. Avant de lancer une instance, vous devez ajouter une clé publique au service Compute.
######  ssh-keygen -q -N ""
Exporter la clé :-1: 
###### openstack keypair create --public-key ~/.ssh/id_rsa.pub mykey
##### Vérification des clé:
###### openstack keypair list

### Création d'un groupe de sécurité
openstack security group create defaultTest
#### Ajouter des règles au groupe de sécurité.
ICMP: openstack security group rule create --proto icmp defaultTest
SSH:  openstack security group rule create --proto tcp --dst-port 22 defaultTest
tcp HTTP: openstack security group rule create --protocol tcp --dst-port 80:80 --remote-ip 0.0.0.0/0 defaultTest
### création et démarage d'une instance:
nom provider-instance, avec son image cirros par defautl qui vient avec openstack.

 ### example`openstack server create --flavor m1.tiny --image cirros --nic net-id=ReseauxInstanceA --security-group default --key-name mykey provider-instance
 
 openstack server create --flavor m1.small --image debian9 --nic net-id=ReseauxInstanceA --security-group defaultTest --key-name mykey provider-instance-debian
![](https://i.imgur.com/nnwwkIb.png)

### Vérifier le statut de l'instance
` $ openstack server list`
vérification de la créaion de l'instance
![](https://i.imgur.com/BROL70p.png)
### Pour avoir les details sur une instance
```
openstack server show <instance ID>
openstack server show e989d9d6-8e25-4125-8f65-48774afbc9e3
```
![](https://i.imgur.com/0pqXxSp.png)


### Demarer une instance
```
openstack server start <server> [<server> ...]
openstack server start e989d9d6-8e25-4125-8f65-48774afbc9e3
```



### Diagnostique

```
openstack server show --diagnostics e989d9d6-8e25-4125-8f65-48774afbc9e3
```
un résumé
```
openstack server resume <server> [<server> ...]
openstack server resume e989d9d6-8e25-4125-8f65-48774afbc9e3
```


### Pour realiser plus de testes possible
j'ai crée une machine qui se trouve dans le même réseaux que notre SVR-PIM-STACK et cette machine est SVR-BD
Nous allons copier le fichier admin_source vers svr-bd
```
scp admin-openrc.sh oumby@svr-bd:/home/oumby/TestOpenStack

```
Deuxièmment nous allons rajouter le certificat de la machine serveur.
```
scp svr-pim-stack-chain.crt oumby@svr-bd:/home/oumby/TestOpenStack

``` 
copier le certificat dans :
```
sudo cp svr-pim-stack-chain.crt /usr/local/share/ca-certificates/
```
puis générer le certificat
```
sudo update-ca-certificates
```

Prérequis installer sur la machine test
```
sudo apt install python3-openstackclient

```
https://docs.openstack.org/nova/rocky/admin/remote-console-access.html




### création d'un machine avec une adresse publique
Nous avons besoin d'une adresses publique pour se connecter à distance sur une instance.
Ip public == adresse flottante.

```
openstack server create --flavor m1.tiny --image cirros \
  --nic net-id=fd581b24-ffb6-4975-9b2c-b264299318ee --security-group default \
  --key-name mykey selfservice-instance
```
svr ubuntu
```
openstack server create --flavor m1.small --image ubuntu-bionic \
  --nic net-id=fd581b24-ffb6-4975-9b2c-b264299318ee --security-group groupUbuntu \
  --key-name mykey ubuntu-instance
```
### Créer une image
`openstack image create --public --disk-format qcow2 --container-format bare --file bionic-server-cloudimg-amd64.img ubuntu-bionic`

### Notre infra réseaux
![](https://i.imgur.com/wlqu6zK.png)

### Ajouter une ip flottante et récupérer l'adresse
afin d'accéder à distance sur infra qui se trouve sur un autre réseaux
A noté Pour les besoins de test j'ai crée une adresse floating
```
$ openstack floating ip create fr-east-1-public
$ openstack floating ip create 3fe2a9f9-69d9-4d2a-9827-d60c239f7d5a
```
### Associé
```
openstack server add floating ip ubuntu-instance 10.20.20.238
openstack server add floating ip selfservice-instance 10.20.20.21 

```
![](https://i.imgur.com/IBDC2Ub.png)

### Dissocier une ip d’une instance 
```
$ openstack server remove floating ip <instance> <ip_flottante>
```
### Test d'utilisation de l'instance à distance
#### Accès via interface Web
`openstack console url show provider-instance-debian`
```
openstack console url show e989d9d6-8e25-4125-8f65-48774afbc9e3
```
##### Problème rencontré: Accéder à l’instance via l'url
Lorsque j'essaye d'afficher l'url 
Unavailable console type novnc. (HTTP 400) (Request-ID: req-3d70b629-c772-4c09-9573-4739723f9b03)
#### Accès en ssh 
```
$ ssh <nom-utilisateur>@<ip-flottante>
```
Nous avons pu tester une connexion ssh à distance
![](https://i.imgur.com/Qqn9eJF.png)
Nos Deux instances

![](https://i.imgur.com/c9neCwg.png)


### Remarque
quand on tape le code 
```
source admin_source.sh
```
même le mot de passe est incorrect y'a aucun messsage d'erreur.

Lorsque vous allez essayer de créer une instance il faudra faire attention à la taille de memoire ram puisque en choisissant une petite taille, il est impossible de créer un vm avec une image ubuntu ou debian 



### Développement des script avec pythonSDK
Développement des script permettant de l'automatisation de la création d'une instance ne fonction:
1. Du gabarit
1. L'image
1. Le disque
1. Groupe de seccurity
1. L'affection à un reseaux avec une adresses ip floatante pour accès à distance
![](https://i.imgur.com/sy0bm0Y.png)
 * essentiel: Contient les bibliothèques ou les fichiers.
 * pim-openstackSDK_clouds.py: est le programme principale.
### TEST API
![](https://i.imgur.com/KXfUxfq.png)


## Conteneurisation Zun
Pour vérifier que nous avons ce service implémenter
```
openstack --help

```
Grace à cette l'option help ou voit qu'on peut bien créer des contenneurs
  `openstack container create  Create new container`
  ![](https://i.imgur.com/d92CVwB.png
  
  
  
## **I. WORKLOAD**
![](https://i.imgur.com/vVW8eVj.png)
 
  Présentation des services Workload et Orchestration


**I-1. Magnum (Provisionnement du moteur d'orchestration de conteneurs)**

* **Présentation**

Magnum rend les moteurs d'orchestration de conteneurs tels que Docker Swarm, Kubernetes et Apache Mesos disponibles en tant que ressources de première classe dans OpenStack. Magnum utilise Heat pour orchestrer une image de système d'exploitation qui contient Docker et Kubernetes et exécute cette image sur des machines virtuelles ou sur du métal nu dans une configuration en cluster.
Il dépend des services suivants : 

![](https://i.imgur.com/YyBxM6n.png)

Le service Container Infrastructure Management comprend les composants suivants :

**magnumclient de ligne de commande**
Une CLI qui communique avec magnum-api pour créer et gérer des clusters de conteneurs. Les développeurs finaux peuvent utiliser directement l'API REST magnum.

**magnum-apiservice**
Une API REST native d'OpenStack qui traite les demandes d'API en les envoyant au magnum-conductorvia AMQP.

**magnum-conductorservice**
S'exécute sur une machine contrôleur et se connecte à la chaleur pour orchestrer un cluster. De plus, il se connecte à un point de terminaison d'API Docker Swarm ou Kubernetes

* **Déploiement**
###### script bash
#! / bin / bash
controller_ip="localhost"
passwd="secret"


#### Use the database access client to connect to the database server as the root user:

db_name="magnum";
db_user="magnum";
password="magnum";
host=localhost;
sql1="create database $db_name;";
sql2="CREATE USER '${db_user}'@'localhost' IDENTIFIED BY '${password}';";
sql3="GRANT ALL ON ${db_name}.* TO '${db_user}'@'localhost';";
sql4="CREATE USER '${db_user}'@'%' IDENTIFIED BY '${password}';";
sql5="GRANT ALL ON ${db_name}.* TO '${db_user}'@'%';";
sql6="${sql1}${sql2}${sql3}${sql4}";
mysql  -e "${sql6}";


#### To create the service credentials, complete these steps
#### Create the magnum user:
openstack user create --domain default \
  --password-prompt magnum

#### Add the admin role to the magnum user:
openstack role add --project service --user magnum admin

#### Create the magnum service entity:

openstack service create --name magnum \
  --description "OpenStack Container Infrastructure Management Service" \
  container-infra

#### Create the Container Infrastructure Management service API endpoints:
openstack endpoint create --region RegionOne \
  container-infra public http://$controller_ip:9511/v1
openstack endpoint create --region RegionOne \
  container-infra internal http://$controller_ip:9511/v1
openstack endpoint create --region RegionOne \
  container-infra admin http://$controller_ip:9511/v1

#### Magnum requires additional information in the Identity service to manage COE clusters. To add this information, complete these steps:

#### Create the magnum domain that contains projects and users:
openstack domain create --description "Owns users and projects \
  created by magnum" magnum

#### Create the magnum_domain_admin user to manage projects and users in the magnum domain:
openstack user create --domain magnum --password-prompt \
  magnum_domain_admin

#### Add the admin role to the magnum_domain_admin user in the magnum domain to enable administrative management privileges by the magnum_domain_admin user:
openstack role add --domain magnum --user-domain magnum --user \
  magnum_domain_admin admin

#### Install the common and library packages:
sudo DEBIAN_FRONTEND=noninteractive apt-get install magnum-api magnum-conductor python3-magnumclient

#### Edit the /etc/magnum/magnum.conf file: 

#### configure the host:

echo -e "
host = $controller_ip \n

#### Use barbican to store certificates:

cert_manager_type = "barbican" \n

#### configure the region name:

region_name = "RegionOne" \n

#### configure database access:
connection = "mysql+pymysql://magnum:${passwd}@controller/magnum" \n

#### configure Identity service access:

memcached_servers = "controller:11211" \n
auth_version = "v3" \n
www_authenticate_uri = "http://controller:5000/v3" \n
project_domain_id = "default" \n
project_name = "service" \n
user_domain_id = "default" \n
password = "${passwd}" \n
username = "magnum" \n
auth_url = "http://controller:5000" \n
auth_type = "password" \n
admin_user = "magnum" \n
admin_password = "${passwd}" \n
admin_tenant_name = "service" \n

trustee_domain_name = "magnum" \n
trustee_domain_admin_name = "magnum_domain_admin" \n
trustee_domain_admin_password = "${passwd}" \n
trustee_keystone_interface = "public" \n

#### configure the driver:
driver = "messaging" \n

#### configure RabbitMQ message queue access:
transport_url = "rabbit://openstack:${passwd}@controller"
 " >>/etc/magnum/magnum.conf

#### Populate Magnum database:
sudo -s /bin/sh -c "magnum-db-manage upgrade" magnum

#### Restart the Container Infrastructure Management services:
service magnum-api restart
service magnum-conductor restart

#### To list out the health of the internal services, namely conductor, of magnum, use:
openstack coe service list

#### Create a keypair on the Compute service:

openstack keypair create --public-key ~/.ssh/id_rsa.pub mykey

#### Create a cluster template for a Docker Swarm cluster using the fedora-atomic-latest image, m1.small as the flavor for the master and the node, public as the external network and 8.8.8.8 for the DNS nameserver, using the following command:
openstack coe cluster template create swarm-cluster-template \
                     --image fedora-atomic-latest \
                     --external-network public \
                     --dns-nameserver 8.8.8.8 \
                     --master-flavor m1.small \
                     --flavor m1.small \
                     --coe swarm

#### Create a cluster with one node and one master using mykey as the keypair, using the following command:

openstack coe cluster create swarm-cluster \
                        --cluster-template swarm-cluster-template \
                        --master-count 1 \
                        --node-count 1 \
                        --keypair mykey



