{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "![Banner](../media/banner1.png)\n", "\n", "---\n", "# Workshop 1.1: Jupyter Notebooks Introduction\n", "* **Contributors**:\n", " * Roberto Rodriguez (@Cyb3rWard0g)\n", " * Jose Rodriguez (@Cyb3rPandah)\n", "* **Agenda**:\n", " * [Overview](#overview)\n", " * [Architecture](#architecture)\n", " * [Deployment](#deployment)\n", " * [Jupyter Flavors](#flavors)\n", "* **Notebook**: [https://aka.ms/Jupyterthon-ws-1-1](https://aka.ms/Jupyterthon-ws-1-1)\n", "* **License**: [Creative Commons Attribution-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-sa/4.0/)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Jupyter Notebooks Overview" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Getting up to speed..\n", "\n", "![](../media/day1/timeline-2021.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Getting up to speed..\n", "\n", "![](../media/day1/timeline-ipython-2021.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# What is Interactive Computing?\n", "\n", "An Interactive computation is a persistent computer program that runs with a **\"human in the loop\"** where the primary mode of steering the program is through the human iteratively writing/running blocks of code and looking at the result.\n", "\n", "Reference:https://www.youtube.com/watch?v=YKmJvHjTGAM&list=PL055Epbe6d5aP6Ru42r7hk68GTSaclYgi&index=29" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# Interactivity as a Protocol\n", "* Read-Evaluate-Print Loop (REPL):\n", " * Takes a single user’s inputs\n", " * Evaluates them\n", " * Returns the result to the user\n", "* A two-process model based on a kernel-client infrastructure\n", " * Kernel: Executes code\n", " * Client: Reads input and present output\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# IPython \n", "\n", "* Released on Dec 10, 2001 by Fernando Perez while he was a graduate student at the University of Colorado\n", " * Release: https://mail.python.org/pipermail/python-list/2001-December/093408.html\n", "* IPython as we know it today grew out of the following three projects:\n", " * ipython by Fernando Pérez.\n", " * IPP by Janko Hauser.\n", " * LazyPython by Nathan Gray.\n", "\n", "Reference: https://ipython.readthedocs.io/en/stable/about/history.html" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "![](../media/day1/python-ipython-notebook.png)\n", "Reference: https://ipython.readthedocs.io/en/stable/interactive/python-ipython-diff.html" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# Fernando Perez Inspiration\n", "* Research with open tools for access and collaboration\n", " * Validated in SciPy India 2010 - Workshop to include students from underprivileged colleges in rural India.\n", "* Scientific\n", " * Business of science is to understand nature\n", " * Science is about opening up the black boxes nature\n", "* Community!\n", " * SciPy: Scientists collaborating and building better tools together!\n", " * Less competitions and more collaboration!\n", " \n", "reference: https://www.youtube.com/watch?v=xuNj5paMuow&list=PL055Epbe6d5aP6Ru42r7hk68GTSaclYgi" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# IPython -> Jupyter Project\n", "\n", "![](../media/day1/ipython-to-jupyter.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "![](../media/day1/ipython-features.png)\n", "\n", "Reference: https://speakerdeck.com/fperez/project-jupyter?slide=5" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "![](../media/day1/ipython-jupyter-features.png)\n", "\n", "Reference: https://speakerdeck.com/fperez/project-jupyter?slide=5" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# What are Jupyter Notebooks?\n", "\n", "The Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text. The Jupyter notebook combines two components:\n", "\n", "* **A web application**: a browser-based tool for interactive authoring of documents which combine explanatory text, mathematics, computations and their rich media output.\n", "* **Notebook documents**: a representation of all content visible in the web application, including inputs and outputs of the computations, explanatory text, mathematics, images, and rich media representations of objects.\n", "\n", "Uses include:\n", "* Data cleaning and transformation\n", "* Statistical modeling\n", "* Data visualization\n", "* Machine learning, and much more\n", "\n", "reference: https://jupyter.org/" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# What does it look like?" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2021-11-30T19:01:24.923703Z", "start_time": "2021-11-30T19:01:24.919935Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hola Roberto!\n" ] } ], "source": [ "print(\"Hola Roberto!\")" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-11-30T19:01:24.936319Z", "start_time": "2021-11-30T19:01:24.926055Z" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "for x in range(5):\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](../media/day1/jupyter-notebooks-classic.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Jupyter Notebook Architecture" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Architecture (Interactive Protocol)\n", "![](../media/day1/jupyter-notebooks-architecture.png)\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Jupyter Notebook Deployments" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# Installing Jupyter Notebooks (Manually)\n", "\n", "**Prerequisite**: Python\n", "\n", "While Jupyter runs code in many programming languages, Python is a requirement (Python 3.3 or greater, or Python 2.7) for installing the JupyterLab or the classic Jupyter Notebook.\n", "\n", "## Classic Jupyter Notebook\n", "\n", "**Using Mamba or Conda**\n", "\n", "```\n", "mamba install -c conda-forge notebook\n", "```\n", "\n", "```\n", "conda install -c conda-forge notebook\n", "```\n", "\n", "**Using PIP**\n", "\n", "```\n", "pip install notebook\n", "```\n", "\n", "Once Jupyter Notebook is installed, you can run it with the following command:\n", "\n", "```\n", "jupyter notebook\n", "\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Installing Jupyter Notebooks (Manually)\n", "\n", "**Prerequisite**: Python\n", "\n", "While Jupyter runs code in many programming languages, Python is a requirement (Python 3.3 or greater, or Python 2.7) for installing the JupyterLab or the classic Jupyter Notebook.\n", "\n", "## JupyterLab\n", "\n", "**Using Mamba or Conda**\n", "\n", "```\n", "mamba install -c conda-forge jupyterlab\n", "```\n", "\n", "```\n", "conda install -c conda-forge jupyterlab\n", "```\n", "\n", "**Using PIP**\n", "\n", "```\n", "pip install jupyterlab\n", "```\n", "\n", "Once JupyterLab is installed, you can run it with the following command:\n", "\n", "```\n", "jupyter-lab\n", "\n", "```" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "\n", "YouTubeVideo('KcoYnFVw9Xs', width=1000, height=800)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# Installing Jupyter Notebooks (Docker CE)\n", "\n", "**Prerequisite**: Docker CE\n", "\n", "You just have to install the community edition of Docker, so that you can install JupyterLab from Docker images containing Jupyter applications and interactive computing tools.\n", "You can use a docker stack image to do any of the following (and more):\n", "\n", "* Start a personal Jupyter Notebook server in a local Docker container\n", "* Run JupyterLab servers for a team using JupyterHub\n", "* Write your own project Dockerfile\n", "\n", "You can use [ready-to-run Docker images](https://github.com/jupyter/docker-stacks) maintained by the Jupyter team:\n", "* Jupyter Github Docker Stacks project: https://github.com/jupyter/docker-stacks\n", "* Jupyter Docker registry: https://hub.docker.com/u/jupyter\n", "* Jupyter Docker Base Image: https://hub.docker.com/r/jupyter/base-notebook/\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running the Jupyter Base Notebook\n", "\n", "```\n", "docker run -p 8888:8888 jupyter/minimal-notebook:3b1f4f5e6cc1\n", "```" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-11-30T19:01:25.088098Z", "start_time": "2021-11-30T19:01:25.028968Z" }, "scrolled": true, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "image/jpeg": "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", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "\n", "YouTubeVideo('KVR1_cVlLRE', width=1000, height=800)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Jupyterthon - OTRF Docker Image\n", "\n", "```\n", "docker run -ti --rm -p 8888:8888 otrf/jupyterthon:2021\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Jupyter Hub\n", "JupyterHub is a set of processes that together provide a single user Jupyter Notebook server for each person in a group. Three major subsystems are started by the jupyterhub command line program:\n", "\n", "* **Hub (Python/Tornado)**: manages user accounts, authentication, and coordinates Single User Notebook Servers using a Spawner.\n", "* **Proxy**: the public facing part of JupyterHub that uses a dynamic proxy to route HTTP requests to the Hub and Single User Notebook Servers. configurable http proxy (node-http-proxy) is the default proxy.\n", "**Single-User Notebook Server (Python/Tornado)**: a dedicated, single-user, Jupyter Notebook server is started for each user on the system when the user logs in. The object that starts the single-user notebook servers is called a Spawner.\n", "\n", "Reference: https://jupyterhub.readthedocs.io/en/latest/reference/technical-overview.html\n", "\n", "![](../media/day1/jupyter-hub-subsystems.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# Enter Binder Project\n", "\n", "* Released in May, 2016\n", "* Updated 2.0 on November, 2019\n", "* The Binder Project is an open community that makes it possible to create shareable, interactive, reproducible environments.\n", "* The main technical product that the community creates is called BinderHub, and one deployment of a BinderHub exists at mybinder.org.\n", "* Who is it for?: \n", " * Researchers, Educators, people analyzing data and people trying to communicate the data analysis to others!!" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# BinderHub\n", "\n", "BinderHub connects several services together to provide on-the-fly creation and registry of Docker images. It utilizes the following tools:\n", "* A cloud provider such Google Cloud, Microsoft Azure, Amazon EC2, and others\n", "* Kubernetes to manage resources on the cloud\n", "* Helm to configure and control Kubernetes\n", "* Docker to use containers that standardize computing environments\n", "* A BinderHub UI that users can access to specify Git repos they want built\n", "* BinderHub to generate Docker images using the URL of a Git repository\n", "* A Docker registry (such as gcr.io) that hosts container images\n", "* JupyterHub to deploy temporary containers for users" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# BinderHub Flow\n", "\n", "![](../media/day1/Binderhub-Architecture.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# Let's Try it!\n", "![](../media/day1/interactive-example.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# JupyterLab Desktop App\n", "\n", "* Released in September 2021.\n", "* Cross-platform standalone application distribution of JupyterLab.\n", "* Desktop app which bundles a Python environment (bundled conda Python env) with popular Python libraries (Numpy, scipy, pandas, ipywidgets and matplotlib).\n", "* Based on Electron with a front-end of JupyterLab inside an embedded browser." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "\n", "YouTubeVideo('1g1c81YTONo', width=1000, height=800)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Jupyter Notebooks Flavors" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Classic Jupyter Notebook\n", "\n", "```\n", "docker run -ti --rm -p 8888:8888 otrf/jupyterthon:2021\n", "```\n", "\n", "![](../media/day1/jupyter-notebook-classic.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# JupyterLab\n", "\n", "```\n", "docker run -ti --rm -e JUPYTER_ENABLE_LAB=yes -p 8888:8888 otrf/jupyterthon:2021\n", "```\n", "\n", "![](../media/day1/jupyterLab.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# VSCode Jupyter Notebook\n", "\n", "* Visual Studio Code\n", "* Python Extension for Visual Studio Code\n", "* Python Interpreter: you can find the steps to install it here.\n", "\n", "**References**:\n", "* https://blog.openthreatresearch.com/first_jupyter_notebook_vscode\n", "* https://blog.openthreatresearch.com/installing_python_extension_vscode" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "\n", "YouTubeVideo('4LrBMHL69VI', width=1000, height=800)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Resources\n", "\n", "* https://the-turing-way.netlify.app/introduction/introduction.html\n", "* https://gist.github.com/fperez/1579699 \n", "* https://mail.python.org/pipermail/python-list/2001-December/093408.html \n", "* https://ipython.org/news.html#ipython-0-12 \n", "* https://speakerdeck.com/fperez/project-jupyter \n", "* https://blog.jupyter.org/rendering-notebooks-on-github-f7ac8736d686 \n", "* https://blog.jupyter.org/binder-2-0-a-tech-guide-2017-fd40515a3a84 \n", "* https://jupyterbook.org/intro.html\n", "* https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html#pip\n", "* https://github.com/jupyter/docker-stacks\n", "* http://ipython.org/news\n", "* https://pypi.org/project/jupyterlite/#history\n", "* https://blog.jupyter.org/jupyterlite-jupyter-%EF%B8%8F-webassembly-%EF%B8%8F-python-f6e2e41ab3fa\n", "* https://github.com/jupyterlab/jupyterlab-desktop#download\n", "* https://blog.jupyter.org/jupyterlab-desktop-app-now-available-b8b661b17e9a\n", "* https://elifesciences.org/labs/a7d53a88/toward-publishing-reproducible-computation-with-binder\n", "* https://tljh.jupyter.org/en/latest/" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Break: 5 Minutes\n", "\n", "![](../media/dog-leash-break.jpg)" ] } ], "metadata": { "celltoolbar": "Slideshow", "hide_input": false, "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.9.5" }, "rise": { "autolaunch": true, "enable_chalkboard": true, "scroll": true }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": false, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": { "height": "calc(100% - 180px)", "left": "10px", "top": "150px", "width": "406.237px" }, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }