00-Resource-Validation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Resource Validation\n",
        "\n",
        "Created for air-gapped clouds, this notebook validates whether the VBD resources in this solution are available and configured in the current subscription.  "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Python Prerequisite Libraries for Validation\n",
        "\n",
        "The following libraries may need to be installed in your kernel to validate the Azure session.  If you do NOT have a connection to the general web, you will need to find a secure means to load these packages on your own Python kernel (using Terminal for your compute instance is the recommended way)."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# verification as to whether packages above are installed or not\n",
        "import subprocess as sp\n",
        "import json\n",
        "\n",
        "from pathlib import Path\n",
        "\n",
        "verifyPkgs = []\n",
        "installedPkgs = []\n",
        "splitChars = [ \"==\", \">=\", \"<=\", \">\", \"<\" ]\n",
        "\n",
        "# check for important and necessary packages/modules\n",
        "filePath = \"./common/requirements.txt\"\n",
        "reqFilePath = Path( filePath )\n",
        "\n",
        "if reqFilePath.exists() :\n",
        "\n",
        "    with open( filePath, \"r\" ) as f :\n",
        "\n",
        "        requirements = [ line.strip() for line in f if line.strip() ]\n",
        "\n",
        "        for requirement in requirements :\n",
        "\n",
        "            verifyPkgs.append( requirement )\n",
        "\n",
        "# load currently installed packages\n",
        "pkgs = sp.check_output( [ \"pip\", \"list\", \"--format\", \"json\" ] )\n",
        "pkgsJson = json.loads( pkgs )\n",
        "\n",
        "# print( pkgsJson )\n",
        "\n",
        "for pkg in pkgsJson :\n",
        "\n",
        "    installedPkgs.append( pkg[ \"name\" ] )\n",
        "\n",
        "# load package list to verify installation\n",
        "for checkPkg in verifyPkgs :\n",
        "\n",
        "    pName = checkPkg\n",
        "    pVer = \"\"\n",
        "    pChar = \"\"\n",
        "\n",
        "    for sc in splitChars :\n",
        "\n",
        "        if sc in checkPkg :\n",
        "\n",
        "            pkgSplit = checkPkg.split( sc )\n",
        "\n",
        "            if len( pkgSplit ) > 1 :\n",
        "\n",
        "                pName = pkgSplit[ 0 ]\n",
        "                pVer = pkgSplit[ 1 ]\n",
        "                pChar = sc\n",
        "\n",
        "            break\n",
        "\n",
        "    if pName not in installedPkgs :\n",
        "\n",
        "        # cmdList = [ \"pip\", \"install\", \"--upgrade\", pName + sc + pVer ]\n",
        "\n",
        "        print( \"*** Attempting to install missing package \" + checkPkg + \" ***\" )\n",
        "\n",
        "        if pVer != \"\" :\n",
        "\n",
        "            cmdList = [ \"pip\", \"install\", \"--upgrade\", pName + pChar + pVer ]\n",
        "\n",
        "        else :\n",
        "\n",
        "            cmdList = [ \"pip\", \"install\", checkPkg ]\n",
        "\n",
        "        print( cmdList )\n",
        "        spOutput = sp.run( cmdList, capture_output = True )\n",
        "\n",
        "        print( spOutput )\n",
        "\n",
        "    else :\n",
        "\n",
        "        print( checkPkg + \" already installed.\" )"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1696012163462
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Python Package Load\n",
        "\n",
        "These packages will be used to validate the resources in this Azure subscription."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from azureml.core import Workspace\n",
        "from azure.identity import DefaultAzureCredential, AzureCliCredential\n",
        "from azure.mgmt.resource import ResourceManagementClient\n",
        "import pkg_resources\n",
        "\n",
        "from azure.mgmt.search import SearchManagementClient\n",
        "from azure.mgmt.cognitiveservices import CognitiveServicesManagementClient\n",
        "\n",
        "import requests\n",
        "import os\n",
        "import json\n",
        "from dotenv import load_dotenv\n",
        "\n",
        "try:\n",
        "    load_dotenv(dotenv_path=\"credentials.env\")\n",
        "    print(\"Successfully loaded environment variables from credentials.env\")\n",
        "    \n",
        "except Exception as e:\n",
        "    print(f\"An error occurred while loading environment variables from credentials.env: {e}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1696012173113
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Uncomment this line if you want to check the packages currently installed\n",
        "# !pip freeze"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1696007057272
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Initialize Resource Management Client\n",
        "\n",
        "Accessing the Azure Resource Management Client will be needed in further validation steps.\n",
        "\n",
        "See documentation at https://learn.microsoft.com/en-us/python/api/overview/azure/identity-readme?view=azure-python"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize Azure credentials\n",
        "from azure.identity import AzureCliCredential\n",
        "credential = AzureCliCredential()\n",
        "\n",
        "# Initialize a Workspace object from the existing workspace you have\n",
        "ws = Workspace.from_config()\n",
        "\n",
        "# Retrieve and print the subscription ID\n",
        "subscription_id = ws.subscription_id\n",
        "print(\"Subscription ID:\", subscription_id)\n",
        "\n",
        "# Initialize the Resource Management client\n",
        "resource_client = ResourceManagementClient(credential, subscription_id)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1696012179076
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Validation:  Azure Cognitive Search\n",
        "\n",
        "Check whether the credentials.env settings for Azure Cognitive Search lead to an active session."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def check_azure_search_service(api_version, endpoint, search_key):\n",
        "    headers = {\n",
        "        'api-key': search_key,\n",
        "        'Content-Type': 'application/json'\n",
        "    }\n",
        "    params = {'api-version': api_version}\n",
        "\n",
        "    # Construct the URL for the request\n",
        "    url = f\"{endpoint}/servicestats\"\n",
        "\n",
        "    try:\n",
        "        # Make the API request\n",
        "        response = requests.get(url, headers=headers, params=params)\n",
        "\n",
        "        # Check if the request was successful\n",
        "        if response.status_code == 200:\n",
        "            print(\"Azure Cognitive Search service is active.  The following output shows the service statistics.\")\n",
        "        else:\n",
        "            print(f\"Received status code {response.status_code}. Service may not be active or the request was invalid.\")\n",
        "\n",
        "        # Parse the JSON content\n",
        "        json_data = json.loads(response.content)\n",
        "\n",
        "        # Pretty-print the JSON data\n",
        "        pretty_str = json.dumps(json_data, indent=4)\n",
        "        print(pretty_str)\n",
        "\n",
        "    except Exception as e:\n",
        "        print(f\"An error occurred: {e}\")\n",
        "\n",
        "# Set your own API version, endpoint, and search key\n",
        "api_version = os.environ['AZURE_SEARCH_API_VERSION']\n",
        "endpoint = os.environ['AZURE_SEARCH_ENDPOINT']\n",
        "search_key = os.environ['AZURE_SEARCH_KEY']\n",
        "\n",
        "check_azure_search_service(api_version, endpoint, search_key)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1696012186481
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Semantic Search\n",
        "\n",
        "Semantic search for Azure Cognitive Search may not be available for your region, and may not be enabled for your search service.\n",
        "The best way to check is to use the Azure Portal using instructions from https://learn.microsoft.com/en-us/azure/search/semantic-how-to-enable-disable?tabs=enable-portal#enable-semantic-search\n",
        "\n",
        "The cell below will validate whether or not the Search service being used had Semantic available or not, whether by simply not being enabled or not being available."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import common.utils as cu\n",
        "\n",
        "searchService = os.environ[ 'AZURE_SEARCH_ENDPOINT' ]\n",
        "resourceGroup = os.environ[ 'AZURE_RESOURCE_GROUP' ]\n",
        "\n",
        "if cu.semanticEnabled( searchService, subscription_id, resourceGroup ) :\n",
        "\n",
        "    print( \"Semantic Search is enabled.\" )\n",
        "\n",
        "else :\n",
        "\n",
        "    print( \"Semantic Search is either disabled or not available for the Search Service instance provided.\" )"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1696012194370
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python38-azureml",
      "language": "python",
      "display_name": "Python 3.8 - AzureML"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.5",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "microsoft": {
      "ms_spell_check": {
        "ms_spell_check_language": "en"
      },
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    },
    "kernel_info": {
      "name": "python38-azureml"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}