ComputeOrchestration/crud_operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<td>\n",
    "   <a target=\"_blank\" href=\"https://www.clarifai.com/\" ><img src=\"https://upload.wikimedia.org/wikipedia/commons/b/bc/Clarifai_Logo_FC_Web.png\" width=256/></a>\n",
    "</td>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<td>\n",
    "<a href=\"https://colab.research.google.com/github/Clarifai/examples/blob/main/ComputeOrchestration/crud_operations.ipynb\" target=\"_blank\"><img\n",
    "src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Colab\"></a>\n",
    "</td>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our longterm goal for the Clarifai platform is to enable users to deploy any model, on any compute, at any scale. We currently support serverless or fully self-managed deployments and only support Nvidia GPUs through Nvidia Triton. \n",
    "\n",
    "With compute orchestration, we aim to evolve our inference stack to be efficient and generalized to support any compute, regardless of hardware provider or deployment model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation and Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is required to set **CLARIFAI_PAT** as Environment Variable.\n",
    "\n",
    "More info on [Personal Access Tokens](https://docs.clarifai.com/clarifai-basics/authentication/personal-access-tokens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install clarifai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CLARIFAI_PAT\"] = \"CLARIFAI_PAT\" # replace with your own PAT key here\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Colab\n",
    "\n",
    "To access config yamls from examples repo, you can clone the repo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git clone /~https://github.com/Clarifai/examples.git\n",
    "%cd /content/examples/ComputeOrchestration/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting User Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from clarifai.client.user import User\n",
    "client = User(user_id=\"USER_ID\", base_url=\"BASE_URL\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute Cluster Operatons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create\n",
    "\n",
    "To create a new compute cluster, we have to provide the `compute_cluster_id` and `config_filepath` to `create_compute_cluster` function of `User` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compute_cluster = client.create_compute_cluster(compute_cluster_id=\"test-compute-cluster\", config_filepath=\"./configs/compute_cluster_config.yaml\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get\n",
    "\n",
    "To get a specific compute cluster we have to provide the `compute_cluster_id` to `compute_cluster` function of `User` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compute_cluster = client.compute_cluster(compute_cluster_id=\"test-compute-cluster\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List\n",
    "\n",
    "To list out the existing compute clusters, we have to call the `list_compute_clusters` function of `User` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_compute_clusters = list(client.list_compute_clusters())\n",
    "print(all_compute_clusters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Init\n",
    "\n",
    "To intialize the `ComputeCluster` class, we have to provide the `user_id` and `compute_cluster_id`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from clarifai.client.compute_cluster import ComputeCluster\n",
    "compute_cluster = ComputeCluster(user_id=\"USER_ID\", compute_cluster_id=\"test-compute-cluster\", base_url=\"BASE_URL\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nodepool Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create\n",
    "\n",
    "To create a new nodepool, we have to provide the `nodepool_id` and `config_filepath` to `create_nodepool` function of `ComputeCluster` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodepool = compute_cluster.create_nodepool(nodepool_id=\"test-nodepool\", config_filepath=\"./configs/nodepool_config.yaml\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get\n",
    "\n",
    "To get a specific nodepool we have to provide the `nodepool_id` to `nodepool` function of `ComputeCluster` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodepool = compute_cluster.nodepool(nodepool_id=\"test-nodepool\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List\n",
    "\n",
    "To list out the existing nodepools, we have to call the `list_nodepools` function of `ComputeCluster` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_nodepools = list(compute_cluster.list_nodepools())\n",
    "print(all_nodepools)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Init\n",
    "\n",
    "To intialize the `Nodepool` class, we have to provide the `user_id` and `nodepool_id`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from clarifai.client.nodepool import Nodepool\n",
    "nodepool = Nodepool(user_id=\"USER_ID\", nodepool_id=\"test-nodepool\", base_url=\"BASE_URL\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deployment Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create\n",
    "\n",
    "To create a new deployment, we have to provide the `deployment_id` and `config_filepath` to `create_deployment` function of `Nodepool` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deployment = nodepool.create_deployment(deployment_id=\"test-deployment\", config_filepath=\"./configs/deployment_config.yaml\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get\n",
    "\n",
    "To get a specific deployment we have to provide the `deployment_id` to `deployment` function of `Nodepool` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deployment = nodepool.deployment(deployment_id=\"test-deployment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List\n",
    "\n",
    "To list out the existing deployments, we have to call the `list_deployments` function of `Nodepool` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_deployments = list(nodepool.list_deployments())\n",
    "print(all_deployments)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Init\n",
    "\n",
    "To intialize the `Deployment` class, we have to provide the `user_id` and `deployment_id`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from clarifai.client.deployment import Deployment\n",
    "deployment = Deployment(user_id=\"USER_ID\", deployment_id=\"test-deployment\", base_url=\"BASE_URL\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Delete Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting Deployments\n",
    "\n",
    "To delete deployments, we have to provide a list of deployment IDs to `delete_deployments` function of `Nodepool` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deployment_ids =[deployment.id for deployment in all_deployments] \n",
    "nodepool.delete_deployments(deployment_ids=deployment_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting Nodepools\n",
    "\n",
    "To delete nodepools, we have to provide a list of nodepool IDs to `delete_nodepools` function of `ComputeCluster` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodepool_ids = [nodepool.id for nodepool in all_nodepools]\n",
    "compute_cluster.delete_nodepools(nodepool_ids=nodepool_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting Compute Clusters\n",
    "\n",
    "To delete compute clusters, we have to provide a list of compute cluster IDs to `delete_compute_clusters` function of `User` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compute_cluster_ids = [compute_cluster.id for compute_cluster in all_compute_clusters]\n",
    "client.delete_compute_clusters(compute_cluster_ids=compute_cluster_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clarifai Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Website**: [https://www.clarifai.com](https://www.clarifai.com/)\n",
    "\n",
    "**Demo**: [https://clarifai.com/demo](https://clarifai.com/demo)\n",
    "\n",
    "**Sign up for a free Account**: [https://clarifai.com/signup](https://clarifai.com/signup)\n",
    "\n",
    "**Developer Guide**: [https://docs.clarifai.com](https://docs.clarifai.com/)\n",
    "\n",
    "**Clarifai Community**: [https://clarifai.com/explore](https://clarifai.com/explore)\n",
    "\n",
    "**Python SDK Docs**: [https://docs.clarifai.com/python-sdk/api-reference](https://docs.clarifai.com/python-sdk/api-reference)\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "v1",
   "language": "python",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}