pt5_exploring_the_api.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Veeam API and Python Part 5 - Exploring the API aka how to work with response data\n",
    "\n",
    "## Updated with the new version of Veeam Easy Connect\n",
    "\n",
    "In this notebook we will go over some of the methods that I work with the data you get back from the API.\n",
    "\n",
    "First the imports:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from veeam_easy_connect import VeeamEasyConnect\n",
    "import getpass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next log into the v11 API using Veeam Easy Connect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "username = \"username\"\n",
    "password = getpass.getpass(\"Enter password: \")\n",
    "address = \"YOUR_VBR_API_ADDRESS\" # ip or DNS\n",
    "\n",
    "veeam_ec = VeeamEasyConnect(username, password, False) # Insecure\n",
    "header = veeam_ec.vbr().login(address)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grab an endpoint from the Veeam Documentation, in this case we will use the /api/v1/jobs endpoint."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = f\"https://{address}:9419/api/v1/jobs\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then make a request to get the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "job_data = veeam_ec.get(url)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the data for later use\n",
    "\n",
    "Here is how you can save the data to a JSON file that can be read later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "with open(\"job_data2.json\", \"w\") as job_data_file:\n",
    "    json.dump(job_data, job_data_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here is how you can read the data back in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"job_data2.json\", \"r\") as job_data_file:\n",
    "    job_data = json.load(job_data_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Structures\n",
    "\n",
    "An example of a List (aka Array) and how to pull out a value using an index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1,2,3,4,5,6,7,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An Example of an Dictionary (aka object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    \"name\": \"ed\", \n",
    "    \"age\": 32\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How we can get one value by calling the key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ed'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And how we can get all the keys and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['name', 'age'])\n",
      "dict_values(['ed', 32])\n"
     ]
    }
   ],
   "source": [
    "print(data.keys())\n",
    "print(data.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are showing that we can create a List of Dictionaries (Array of Objects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_list = [data, data, data, data]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'ed', 'age': 32},\n",
       " {'name': 'ed', 'age': 32},\n",
       " {'name': 'ed', 'age': 32},\n",
       " {'name': 'ed', 'age': 32}]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And how we can first index out the first dictionary and then access a key in the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ed'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_list[0]['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## /api/v1/jobs object/dict walk through\n",
    "\n",
    "Here we will walk through the dictionary that we received back from the API to pull out relevant data.\n",
    "\n",
    "The aim here is to be able to create a new list of dictionaries that have the:\n",
    "\n",
    "* Job Name\n",
    "* VMs in the Job\n",
    "\n",
    "We start with checking for the keys in the response."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['data', 'pagination'])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job_data.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can see we have to keys, we want to follow the 'data' path\n",
    "\n",
    "NOTE the \";\" has been added to remove the output for GitHub, remove when running it yourself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "job_data['data'];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see from the [ that we are looking at a List so we need to index the first item out (job)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "job_data['data'][0];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That removes the [ at the start so we know we are looking at a Dictionary.\n",
    "\n",
    "Next we can have a look at the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['isHighPriority', 'virtualMachines', 'storage', 'guestProcessing', 'schedule', 'type', 'id', 'name', 'description', 'isDisabled'])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job_data['data'][0].keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the saved JSON file we know that the VMs are inside the \"virtualMachines\" and the Job name is under \"name\".\n",
    "\n",
    "We'll aim for the Job name first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ActiveDirectory'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job_data['data'][0]['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we need to follow the same process as before, following data structure to the data we need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'WS2016-AD-DNS'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job_data['data'][0]['virtualMachines']['includes'][0]['inventoryObject']['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we will use a double loop to get the data from the API response that we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list to receive the new dicts\n",
    "job_vm_map = []\n",
    "\n",
    "# Start the first loop\n",
    "for i in job_data['data']:\n",
    "    # create a temporary list to hold all the VM names from each job\n",
    "    vm_names = []\n",
    "    # Start the second loop through the VM dicts\n",
    "    for j in i['virtualMachines']['includes']:\n",
    "        data = j['inventoryObject']['name']\n",
    "        # Add them to the temporary List\n",
    "        vm_names.append(data)\n",
    "    # Create a new dict with the Job Name and the VMs\n",
    "    job_info = {\n",
    "        \"jobName\": i['name'],\n",
    "        \"vmsInJob\": vm_names\n",
    "    }\n",
    "    # Add that to the first list\n",
    "    job_vm_map.append(job_info)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can now look at the new List of Dicts which have the Job Names and VMs mapped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'jobName': 'ActiveDirectory', 'vmsInJob': ['WS2016-AD-DNS']},\n",
       " {'jobName': 'k8s',\n",
       "  'vmsInJob': ['K8s-Control', 'K8s-Worker1', 'K8s-Worker2', 'K8s-Worker3']},\n",
       " {'jobName': 'Mixed SOBR', 'vmsInJob': ['Small Debian2']},\n",
       " {'jobName': 'PerJob', 'vmsInJob': ['Small Debian2', 'Small Debian3']},\n",
       " {'jobName': 'SQL1', 'vmsInJob': ['SQL1']},\n",
       " {'jobName': 'Tiny NFS vm', 'vmsInJob': ['TinyVM']},\n",
       " {'jobName': 'TinyVM2Netapp', 'vmsInJob': ['TinyVM']}]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job_vm_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next video we will take a look at Pandas 🐼"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "907c7fe4cb4e511b42727ae84c4d85e9a0cc88b3b995d6fcfd67872026398923"
  },
  "kernelspec": {
   "display_name": "Python 3.9.6 64-bit",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}