Rating

Valoriser les métriques Monasca / Ceilometer avec CloudKitty

Cet article décrit comment installer et configurer Monasca-Ceilometer et CloudKitty pour permettre à CloudKitty de collecter des métriques à travers l’API de Monasca.

Public visé : opérateurs et administrateurs OpenStack familiers avec Ceilometer et CloudKitty. Avoir déjà manipulé Monasca facilitera la compréhension.

Par Luka Peschke, Consultant Cloud et Développeur CloudKitty @ Objectif Libre

 

Depuis la release Queens d’OpenStack, il est possible d’intégrer CloudKitty (le composant officiel de valorisation d’OpenStack) avec le module Monasca. Pour ce faire, nous allons installer Monasca-Ceilometer pour permettre à Ceilometer de publier les métriques dans Monasca.

Pré-requis

Pour les étapes qui suivent, vous avez besoin d’un cloud OpenStack opérationnel comprenant Monasca et Ceilometer (Ceilometer sera installé from source).

Etape 1 : installation de Monasca-Ceilometer

Tout d’abord, clonez monasca-ceilometer:

$ git clone https://github.com/openstack/monasca-ceilometer /tmp/monasca-ceilometer
$ cd /tmp/monasca-ceilometer/ceilosca/ceilometer

Ensuite, copiez les fichiers requis vers le répertoire source de Ceilometer :

$ cp monasca_client.py $CEILO_SOURCE_DIR/ceilometer/
$ cp publisher/* $CEILO_SOURCE_DIR/ceilometer/publisher/
$ cp -r ceilosca_mapping/ $CEILO_SOURCE_DIR/ceilometer/
$ cp opts.py monasca_ceilometer_opts.py $CEILO_SOURCE_DIR/ceilometer/

Vous allez également devoir copier certains fichiers de configuration :

$ cp /tmp/monasca-ceilometer/etc/ceilometer/monasca_pipeline.yaml \
     /tmp/monasca-ceilometer/etc/ceilometer/ceilosca_pipeline.yaml \
     /tmp/monasca-ceilometer/etc/ceilometer/monasca_field_definitions.yaml \
     /etc/ceilometer/

Une fois ces fichiers copiés, vous devez éditer le fichier de Ceilometer setup.cfg. Ajoutez la ligne suivante dans la section ceilometer.sample.publisher = :

monasca = ceilometer.publisher.monclient:MonascaPublisher

La publication d’événement n’est pas encore supportée par Monasca-Ceilometer, il n’est donc pas nécessaire d’éditer ceilometer.event.publisher.

Le fichier de configuration de Ceilometer doit être adapté. Editez /etc/ceilometer/pipeline.yaml pour publier les métriques dans Monasca. Par exemple :

sources:
    - name: meter_source
      meters:
          - "*"
      sinks:
          - meter_sink
[...]
sinks:
    - name: meter_sink
      transformers:
      publishers:
            - monasca://http://10.0.2.15:8070/v2.0

Ensuite, éditez ceilometer.conf:

# Ajoutez la section suivante:
[monasca]
service_auth_url = $KEYSTONE_URL
service_region_name = RegionOne
service_password = ********
service_username = ceilometer
service_project_name = service
service_domain_name = Default
service_auth_type = password
enable_api_pagination = True
database_retry_interval = 5
database_max_retries = 5

# Ajoutez ceci à la section [database]:
[database]
connection = monasca://http://10.0.2.15:8070/v2.0

Vous pouvez également éditer /etc/ceilometer/monasca_field_definitions.yml pour ajouter des dimensions (attributs) à vos ressources.

Une fois que les fichiers de configuration sont corrects, vous pouvez (ré)installer Ceilometer:

$ cd $CEILO_SOURCE_DIR
$ pip install .
$ pip install python-monascaclient

Enfin, ajouter le role « monasca-user » à Ceilometer:

$ openstack role add --user ceilometer --project service monasca-user

Vous pouvez maintenant (re)démarrer les différents services de Ceilometer. Etant donné que Ceilometer publie les métriques en étant identifié sur le projet « service », vous pouvez lister les métriques avec la commande suivante:

$ openstack project list
+----------------------------------+-------------------+
| ID                               | Name              |
+----------------------------------+-------------------+
| 9a7d3fdd2eec47b1b11a9c5a265e3d87 | myproject         |
| e5f331d9e8d1469aba1c80e5a79cdd01 | service           |
| f7b7b3560b8f455bbf406bd0cc12b1c3 | admin             |
+----------------------------------+-------------------+

# Liste les métriques pour le tenant 'myproject'
$ monasca metric-list --tenant-id e5f331d9e8d1469aba1c80e5a79cdd01 \
--dimensions project_id=9a7d3fdd2eec47b1b11a9c5a265e3d87

Etape 2: installation de CloudKitty

Tout d’abord, clonez et installez Cloudkitty:

$ git clone https://github.com/openstack/cloudkitty -b stable/queens /opt/cloudkitty
$ pip install ./cloudkitty

# Copiez les fichiers de configuration
$ mkdir /etc/cloudkitty
$ cp /opt/cloudkitty/etc/cloudkitty/* /etc/cloudkitty

Ensuite, créez la base de données ‘cloudkitty’:

$ mysql -uroot -padminpass << EOF
CREATE DATABASE cloudkitty;
GRANT ALL PRIVILEGES ON cloudkitty.* \
      TO $CK_DB_USER@'%' IDENTIFIED BY $CK_DB_PASS;
FLUSH PRIVILEGES;
EOF

Maintenant, il faut ajouter la configuration de base à CloudKitty:

$ cat > /etc/cloudkitty/cloudkitty.conf << EOF
[DEFAULT]
debug = True
transport_url = rabbit://$RABBIT_USER:$RABBIT_PASS@$RABBIT_URL:$RABBIT_PORT/

[service_credentials]
auth_url = $KEYSTONE_URL
region_name = RegionOne
password = ******
username = cloudkitty
project_name = service
project_domain_id = default
user_domain_id = default
auth_type = password

[keystone_authtoken]
auth_section = service_credentials

[database]
connection = mysql+pymysql://CK_DB_USER:CK_PASS@127.0.0.1/cloudkitty?charset=utf8

# Le backend de stockage que CloudKitty doit utiliser
[storage]
backend = sqlalchemy

[tenant_fetcher]
backend = keystone

[keystone_fetcher]
auth_section = service_credentials
keystone_version = 3

# Information d'authentification pour monascaclient
[collector_monasca]
auth_section = service_credentials
EOF

Enfin, il faut configurer la collecte des métriques. Editez /etc/cloudkitty/metrics.yml:

- name: OpenStack

  collector: monasca
  # Cloudkitty va collecter des métriques toutes les 3600 secondes. Chaque métrique sera valorisée
  # par période d'une heure
  period: 3600
  # CloudKitty attendra 2 périodes de collecte, ie. la période de 9 à 10 heures du matin
  # sera traitée à 12h. Cela laisse du temps au backend de stockage
  # pour l'aggrégation des métriques
  wait_periods: 2

  # Pour ce post, nous allons valoriser des volumes Cinder et des images Glance
  services:
    - volume
    - image

  # Monasca n'a pas de notion de ressource, donc on associe directement les services
  # à des métriques
  services_objects:
    volume: volume.size
    image: image.size

  # On spécifie la méthode d'aggrégation pour chaque métrique
  services_metrics:
    volume:
      - volume.size: max
    image:
      - image.size: max

  # Détail des unités et conversions
  metrics_units:
     volume:
       volume.size:
         unit: GiB
     # La métrique image.size est en bytes, mais nous voulons valoriser des Mebibytes.
     # Vous pouvez spécifier un facteur et un offset pour chaque métrique, les mesures
     # seront converties de la manière suivante:
     # result = measures * factor + offset
     # (factor vaut 1 et offset vaut 0 par défaut)
     image:
       image:
         unit: MiB
         factor: 1/1048576

Voilà pour la partie configuration.

CloudKitty doit maintenant être enregistré comme un service OpenStack.

# Création du service rating
$ openstack user create --password ****** cloudkitty
$ openstack service create --name cloudkitty rating
$ openstack role add --user cloudkitty --project service admin
$ openstack role create rating

# Création des endpoints requis
$ openstack endpoint create --region RegionOne rating admin http://$CK_URL:8889
$ openstack endpoint create --region RegionOne rating public http://$CK_URL:8889
$ openstack endpoint create --region RegionOne rating internal http://$CK_URL:8889

# IMPORTANT: Autorise CloudKitty à collecter des métriques monasca
$ openstack role add --user cloudkitty --project service monasca-user

# Configuration de CloudKitty pour valoriser notre projet
$ openstack role add --user cloudkitty --project myproject rating

# On vérifie que tout est en ordre
$ openstack role assignment list --user cloudkitty --names
+--------------+--------------------+-------+-------------------+--------+-----------+
| Role         | User               | Group | Project           | Domain | Inherited |
+--------------+--------------------+-------+-------------------+--------+-----------+
| rating       | cloudkitty@Default |       | myproject@Default |        | False     |
| admin        | cloudkitty@Default |       | service@Default   |        | False     |
| monasca-user | cloudkitty@Default |       | service@Default   |        | False     |
+--------------+--------------------+-------+-------------------+--------+-----------+

Nous pouvons maintenant initialiser les backends de stockage de CloudKitty.

$ cloudkitty-dbsync upgrade
$ cloudkitty-storage-init

Il est maintenant temps de définir les règles de valorisation, ce qui nécessite de démarrer l’API.

L’API devrait être servie comme une application WSGI avec un « vrai » serveur (cf. https://docs.openstack.org/cloudkitty/latest/install/mod_wsgi.html).

Par contre, si vous utilisez un environnement de test, vous pouvez utiliser la commande suivante :

$ cloudkitty-api --port 8889 -- --config-dir /etc/cloudkitty/

Etape 3: profitez!

Pour définir les règles de facturation, nous allons utiliser le module Hashmap de CloudKitty (https://docs.openstack.org/cloudkitty/latest/admin/rating/hashmap.html):

# Activation du module hashmap
$ cloudkitty module-enable -n hashmap
+---------+---------+----------+
| Module  | Enabled | Priority |
+---------+---------+----------+
| hashmap | True    | 1        |
+---------+---------+----------+

# Création du service image
$ cloudkitty hashmap-service-create -n image
+------------+--------------------------------------+
| Property   | Value                                |
+------------+--------------------------------------+
| name       | image                                |
| service_id | dfcf1764-b76f-45a1-b671-339cfcc65abf |
+------------+--------------------------------------+

# On valorise chaque image à 0.002 par MiB par période de collecte (1 heure)
# Ceci est une regle de valorisation globale, mais vous pouvez spécifier un tenant
# si vous voulez valoriser vos tenants différemment
$ cloudkitty hashmap-mapping-create -s dfcf1764-b76f-45a1-b671-339cfcc65abf -t flat -c 0.002
+------------+--------------------------------------+
| Property   | Value                                |
+------------+--------------------------------------+
| cost       | 0.00200000                           |
| field_id   | None                                 |
| group_id   | None                                 |
| mapping_id | e47704bf-831a-459c-88b0-ec10c8ac9c21 |
| service_id | dfcf1764-b76f-45a1-b671-339cfcc65abf |
| tenant_id  | None                                 |
| type       | flat                                 |
| value      |                                      |
+------------+--------------------------------------+

$ cloudkitty hashmap-service-create -n volume
+------------+--------------------------------------+
| Property   | Value                                |
+------------+--------------------------------------+
| name       | volume                               |
| service_id | 67fcaa4d-ca36-42ff-bd70-82f860d298e3 |
+------------+--------------------------------------+

# Les volumes seront valorisés 0.001 par GiB par heure
$ cloudkitty hashmap-mapping-create -s 67fcaa4d-ca36-42ff-bd70-82f860d298e3 -c 0.001 -t flat
+------------+--------------------------------------+
| Property   | Value                                |
+------------+--------------------------------------+
| cost       | 0.00100000                           |
| field_id   | None                                 |
| group_id   | None                                 |
| mapping_id | 72a65d37-89f8-4573-ba51-8980916dc258 |
| service_id | 67fcaa4d-ca36-42ff-bd70-82f860d298e3 |
| tenant_id  | None                                 |
| type       | flat                                 |
| value      |                                      |
+------------+--------------------------------------+

Nous avons maintenant besoin de données pour le tenant ‘myproject’. Créez quelques volumes Cinder, téléchargez quelques images dans Glance et attendez que Ceilometer publie des métriques dans Monasca.

Si vous souhaitez des résultats immédiats, vous pouvez passer le paramètre du collecteur wait_period à 0, mais ceci n’est pas recommandé en production (Monasca, Gnocchi, etc… ont besoin de temps pour aggréger les mesures et vous pourriez en perdre certaines).

Vous pouvez maintenant démarrer le processeur de CloudKitty :

$ cloudkitty-processor --config-file /etc/cloudkitty/cloudkitty.conf

Ce processeur collecte des métriques en démarrant au début du mois en cours. Attendez un moment, jusqu’à ce que le processeur ait rattrapé l’heure courante.

Vous pouvez ensuite obtenir le valorisation de votre cloud:

# Les commandes suivantes sont lancées en tant qu'utilisateur du projet 'mytenant'

# Obtention de la valorisation totale
$ cloudkitty summary-get
+----------------------------------+---------------+---------+---------------------+
| Tenant ID  | Resource Type | Rate    | Begin Time          | End Time            |
+----------------------------------+---------------+---------+---------------------+
| 9a7[...]87 | ALL           | 0.35468 | 2018-02-01T00:00:00 | 2018-03-01T00:00:00 |
+----------------------------------+---------------+---------+---------------------+

# Obtention de la valorisation totale groupée par tenant
$ cloudkitty summary-get -g res_type
+----------------------------------+---------------+---------+---------------------+
| Tenant ID  | Resource Type | Rate    | Begin Time          | End Time            |
+----------------------------------+---------------+---------+---------------------+
| 9a7[...]87 | image         | 0.30368 | 2018-02-01T00:00:00 | 2018-03-01T00:00:00 |
| 9a7[...]87 | volume        | 0.051   | 2018-02-01T00:00:00 | 2018-03-01T00:00:00 |
+----------------------------------+---------------+---------+---------------------+

Conclusion

Il est maintenant possible d’intégrer CloudKitty, Ceilometer et Monasca, et d’appliquer des champs sur toutes les dimensions spécifiées dans /etc/ceilometer/monasca_field_definitions.yml.

Etant donné que les services et les métriques de CloudKitty sont maintenant configurables via un fichier YAML, vous pouvez valoriser toutes les métriques publiées dans Monasca par Ceilometer !

En savoir plus sur les nouveautés de CloudKitty.