snowpark_container_services_python_api.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quickstart: Getting Started with the Snowflake Python API\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating and managing Snowpark Container Services with the Snowflake Python API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook contains **sample code** that runs an NGINX web server using Snowpark Container Services, all running in Snowflake. The notebook is provided for convenience and demonstrative purposes. If your Snowflake account is in one of the select AWS regions where Snowpark Container Services is in Public Preview, you can use the code in this notebook as reference to help you orchestrate Snowpark Container Services using the Snowflake Python API.\n",
    "\n",
    "Create our connection to Snowflake, create a `Root` object, and establish references to existing Snowflake objects in the Snowflake account:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-14T21:30:27.699157Z",
     "start_time": "2023-06-14T21:30:27.181547Z"
    }
   },
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "from snowflake.core import Root\n",
    "from snowflake.core.service import ServiceSpecInlineText\n",
    "from snowflake.snowpark import Session\n",
    "\n",
    "session = Session.builder.config(\"connection_name\", \"python_api\").create()\n",
    "api_root = Root(session)\n",
    "database = api_root.databases[\"spcs_python_api_db\"]\n",
    "schema = database.schemas[\"public\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run a service, we'll need to create a compute pool, which can be defined and created with the Snowflake Python API:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-14T21:30:28.153875Z",
     "start_time": "2023-06-14T21:30:27.696789Z"
    }
   },
   "outputs": [],
   "source": [
    "new_compute_pool_def = ComputePool(\n",
    "    name=\"MyComputePool\"\n",
    "    instance_family=\"CPU_X64_XS\",\n",
    "    min_nodes=1,\n",
    "    max_nodes=2,\n",
    ")\n",
    "\n",
    "new_compute_pool = api_root.compute_pools.create(new_compute_pool_def)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The container needed lives in an image repository, listed as a stage in Snowflake. Create a reference to the image repository so that we can grab important information related to the container as we define our service (in subsequent cells)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-14T21:30:35.428282Z",
     "start_time": "2023-06-14T21:30:35.334463Z"
    }
   },
   "outputs": [],
   "source": [
    "image_repository = schema.image_repositories[\"MyImageRepository\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Let's create our service. A service refers to a collection of containers running in a compute pool, all orchestrated in Snowflake. Using a compute pool I’ve already setup, and my container image, we can start the service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-14T21:30:37.058491Z",
     "start_time": "2023-06-14T21:30:35.429512Z"
    }
   },
   "outputs": [],
   "source": [
    "from textwrap import dedent\n",
    "from io import BytesIO\n",
    "from snowflake.core.service import Service\n",
    "session.use_role(\"my_role\")  # Perhaps this role has permission to create and run a service\n",
    "specification = dedent(f\"\"\"\\\n",
    "            spec:\n",
    "              containers:\n",
    "              - name: web-server\n",
    "                image: {image_repository.fetch().repository_url}/nginx:latest\n",
    "              endpoints:\n",
    "              - name: ui\n",
    "                port: 80\n",
    "                public: true\n",
    "             \"\"\")\n",
    "\n",
    "service_def = Service(\n",
    "    name=\"MyService\",\n",
    "    compute_pool=\"MyComputePool\",\n",
    "    spec=ServiceSpecInlineText(specification),\n",
    "    min_instances=1,\n",
    "    max_instances=1,\n",
    ")\n",
    "\n",
    "nginx_service = schema.services.create(service_def)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the service created, the next cell will output the status of the service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-14T21:30:42.364676Z",
     "start_time": "2023-06-14T21:30:37.058738Z"
    }
   },
   "outputs": [],
   "source": [
    "pprint(nginx_service.get_service_status(timeout=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It'll take a few minutes for the endpoints that are needed to access the service to be provisioned. The next cell isn't specific to Snowpark Container Services or the Snowflake Python API – it simply provides a handy way to inspect whether the endpoints are ready. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-14T21:30:55.144367Z",
     "start_time": "2023-06-14T21:30:55.012348Z"
    }
   },
   "outputs": [],
   "source": [
    "# The server gives us an \"in progress\" status string while the service\n",
    "# is provisioned, so we'll wait a bit for the service to be available (the\n",
    "# result is a JSON parsable string). It can take up to\n",
    "# two minutes to provision the service.\n",
    "import json, time\n",
    "while True:\n",
    "    public_endpoints = nginx_service.fetch().public_endpoints\n",
    "    try:\n",
    "        endpoints = json.loads(public_endpoints)\n",
    "    except json.JSONDecodeError:\n",
    "        print(public_endpoints)\n",
    "        time.sleep(15)\n",
    "    else:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the endpoints are provisioned, the next cell will open the public endpoints in your browser."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Visiting {endpoints['ui']} in your browser. You may need to log in there.\")\n",
    "import webbrowser\n",
    "webbrowser.open(f\"https://{endpoints['ui']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If successful, you should see the NGINX success page in your browser when visiting the endpoint."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, suspend the compute pool and service:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-14T21:30:55.548355Z",
     "start_time": "2023-06-14T21:30:55.143340Z"
    }
   },
   "outputs": [],
   "source": [
    "new_compute_pool_def.suspend()\n",
    "nginx_service.suspend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, delete the compute pool and service:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_compute_pool_def.delete()\n",
    "nginx_service.delete()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Close your session with Snowflake:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations! In this notebook, you learned the fundamentals for managing Snowpark Container Services using the Snowflake Python API.\n",
    "\n",
    "For more information, see the following resources:\n",
    "\n",
    "* [Snowflake Documentation: Snowflake Python API](https://docs.snowflake.com/en/LIMITEDACCESS/snowflake-python-api/snowflake-python-overview)\n",
    "\n",
    "* [Snowflake Documentation: Snowpark Container Services](https://docs.snowflake.com/en/developer-guide/snowpark-container-services/overview)\n",
    "\n",
    "* [Snowflake Python API Reference Documentation](https://docs.snowflake.com/en/LIMITEDACCESS/snowflake-python-api/reference/0.1.0/index.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}