Consumir el API REST de Red Hat Enterprise Virtualization Manager (RHEV-Manager) no es muy común que digamos, por lo mismo que necesitamos contar con una infraestructura RHEV de pruebas para iniciar con nuestros desarrollos (a no ser que exista uno de libre disponibilidad ) y como he escuchado decir en muchas ocasiones se necesita un ambiente donde «podamos malograr». Pero bien, consumir un API REST con Python sea del RHEV-Manager u otro, da igual, se puede utilizar los mismos lineamientos para establecer la comunicación con un API REST, aunque para el presente ejemplo, vamos a usar recursos propios del RHEV-Manager.
La plataforma del RHEV-Manager, ofrece un API REST para poder consumir los recursos de la infraestructura de virtualización de Red Hat.
Para consumir esta API REST, vamos a utilizar requests. Entonces, primero creamos nuestro entorno en python.
| $ virtualenv-2.7 –no-site-packages –distribute venv | |
| $ source venv/bin/activate | |
| $ pip install requests |
Creamos nuestro cliente python rhevmanager.py. A la clase RhevManager la instanciaremos con los valores necesarios para consumir el API REST, como son los datos de autenticación (usuario y contraseña), un certificado y la URL de la API.
| # -*- coding: utf-8 -*- | |
| “”” El RhevManager se conecta al API REST del RHEV-Manager“”” | |
| __author__ = “Gonzalo Chacaltana Buleje“ | |
| import requests | |
| import json | |
| from requests.auth import HTTPBasicAuth | |
| class RhevManager(object): | |
| def __init__(self,api_url=None,username=None,password=None,cert=None): | |
| self.api_url = api_url | |
| self.username = username | |
| self.password = password | |
| self.cert = cert | |
| def request(self, url, data = None, method = “GET“): | |
| headers = self.build_header() | |
| if method == “GET“: | |
| response = requests.get(url,verify=self.cert,auth=HTTPBasicAuth(self.username, self.password),headers=headers) | |
| if method == “POST“: | |
| pass | |
| if response.status_code == 200 : | |
| return response.json() | |
| if response.status_code == 201 : | |
| pass | |
| code_error = “(%s)“ % response.status_code | |
| message = {code_error:response.reason} | |
| if response.status_code == 400 : | |
| print response.raise_for_status() | |
| if response.status_code == 401 : | |
| return json.dumps(message) | |
| if response.status_code == 402 : | |
| return json.dumps(message) | |
| if response.status_code == 403 : | |
| return json.dumps(message) | |
| if response.status_code == 404 : | |
| return json.dumps(message) | |
| if response.status_code == 408 : | |
| return json.dumps(message) | |
| if response.status_code == 500 : | |
| return json.dumps(message) | |
| def get_home_document(self): | |
| return self.request(self.api_url) | |
| def build_header(self, accept=None, content_type=None): | |
| accept = “application/json“ if accept==None else accept | |
| content_type = “application/json“ if content_type==None else content_type | |
| return {“Accept“:accept, “Content-Type“:content_type} |
Ahora, crearemos un archivo demo.py, donde instanciaremos un objeto de la clase anteriormente desarrollada, enviándole como parámetros la URL de la API, las credenciales de autenticación (usuario y contraseña) y el certificado. De esta forma, podremos invocar a los métodos de esta clase, donde internamente se está armando el request correcto, y solo preocuparnos por enviarme la URL del recurso que queremos obtener.
| # -*- coding: utf-8 -*- | |
| __author__ = “Gonzalo Chacaltana @gchacaltanab“ | |
| from rhevmanager import RhevManager | |
| class Demo(object): | |
| def __init__(self,api_url,username,password,cert): | |
| self.api_url = api_url | |
| rhev_username = username | |
| rhev_password = password | |
| rhev_cert = cert | |
| self.rhevm = RhevManager(self.api_url,rhev_username,rhev_password,rhev_cert) | |
| self.endpoints = self.build_link_resource_rhevm() | |
| def build_link_resource_rhevm(self): | |
| “””Crea lista de recursos del home document del API REST“”” | |
| data = self.rhevm.get_home_document() | |
| endpoints = {} | |
| for item in data[‘link‘]: | |
| endpoints[item[‘rel‘]] = self.api_url + item[‘href‘] | |
| return endpoints | |
| def get_templates(self, template_id=None): | |
| url_format = self.endpoints[‘templates‘] | |
| url = url_format + “/“ + template_id if template_id != None else url_format | |
| return self.rhevm.request(url) | |
| def get_events(self, event_id = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘events‘] | |
| url = url_format + “/“ + event_id if event_id != None else url_format | |
| return self.rhevm.request(url) | |
| def get_users(self, user_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘users‘] | |
| url = url_format + “/“ + user_guid if user_guid != None else url_format | |
| return self.rhevm.request(url) | |
| def get_vm(self, vm_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘vms‘] | |
| url = url_format + “/“ + vm_guid if vm_guid != None else url_format | |
| return self.rhevm.request(url) | |
| def get_clusters(self, cluster_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘clusters‘] | |
| url = url_format + “/“ + cluster_guid if cluster_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_datacenters(self, datacenter_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘datacenters‘] | |
| url = url_format + “/“ + datacenter_guid if datacenter_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_hosts(self, host_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘hosts‘] | |
| url = url_format + “/“ + host_guid if host_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_networks(self, network_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘networks‘] | |
| url = url_format + “/“ + network_guid if network_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_roles(self, role_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘roles‘] | |
| url = url_format + “/“ + role_guid if role_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_storagedomains(self, storagedomain_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘storagedomains‘] | |
| url = url_format + “/“ + storagedomain_guid if storagedomain_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_tags(self, tag_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘tags‘] | |
| url = url_format + “/“ + tag_guid if tag_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_groups(self, group_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘groups‘] | |
| url = url_format + “/“ + group_guid if group_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_domains(self, domain_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘domains‘] | |
| url = url_format + “/“ + domain_guid if domain_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_vmpools(self, vmpool_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘vmpools‘] | |
| url = url_format + “/“ + vmpool_guid if vmpool_guid != None else url_format | |
| return rhevm.request(url) | |
| def get_disks(self, disk_guid = None): | |
| rhevm = self.connect_rhev_manager() | |
| url_format = self.endpoints[‘disks‘] | |
| url = url_format + “/“ + disk_guid if disk_guid != None else url_format | |
| return rhevm.request(url) | |
| obj = Demo(api_url,username,password,cert) | |
| obj.get_events() | |
| obj.get_users() | |
| obj.get_templates() | |
| obj.get_clusters() | |
| obj.get_datacenters() | |
| obj.get_hosts() | |
| obj.get_networks() |
La documentación del API de RHEV-Manager, lo pueden encontrar en el siguiente enlace.
Te esperamos en los próximos artículos en donde hablaremos mas acerca de estos temas que hoy en día son de importancia e interés en el mundo de la tecnología.
