One place for hosting & domains

      Notebook

      Cómo instalar Jupyter Notebook, ejecutarla y conectarse a ella en un servidor remoto


      El autor seleccionó la Apache Software Foundation para que recibiera una donación de $100 como parte del programa Write for DOnations.

      Introducción

      Jupyter Notebook es una aplicación web interactiva de código abierto que le permite escribir y ejecutar código informático en más de 40 lenguajes de programación, incluidos Python, R, Julia y Scala. Jupyter Notebook, un producto de Project Jupyter, es útil para la codificación iterativa, ya que le permite escribir un pequeño fragmento de código, ejecutarlo y obtener el resultado.

      Jupyter Notebook proporciona la capacidad de crear documentos notebook, denominados simplemente “notebooks”. Los notebooks creados desde Jupyter Notebook son documentos de investigación reproducibles e intercambiables que incluyen elementos de texto enriquecido, ecuaciones, código y sus resultados (cifras, tablas, tramas interactivas). También pueden exportarse a archivos de código sin procesar, HTML o documentos PDF, o bien utilizarse para crear presentaciones de diapositivas interactivas o páginas web.

      A través de este artículo, aprenderá a instalar y configurar la aplicación Jupyter Notebook en un servidor web de Ubuntu 18.04, y también a conectarse a ella desde su computadora local. Además, también veremos cómo utilizar Jupyter Notebook para ejecutar un ejemplo de código de Python.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Además, si su computadora local tiene Windows instalado, deberá instalar PuTTY para establecer un túnel SSH hacia su servidor. Siga nuestra guía Cómo crear claves SSH con PuTTY en Windows para descargar e instalar PuTTY.

      Paso 1: Instalar Jupyter Notebook

      Dado que los notebooks se utilizan para escribir, ejecutar y ver el resultado de pequeños fragmentos de código, primero deberá configurar la compatibilidad de lenguajes de programación. Jupyter Notebook utiliza un kernel específico de lenguaje, un programa informático que ejecuta e inspecciona código. Jupyter Notebook tiene muchos kernels en diferentes lenguajes y el predeterminado es IPython. A través de este tutorial, configurará Jupyter Notebook para ejecutar código de Python a través del kernel de IPython.

      Suponiendo que haya seguido los tutoriales con vínculos de la sección de requisitos previos, debería tener instalados Python 3, pip y un entorno virtual. Los ejemplos de esta guía cumplen con la convención utilizada en el tutorial de los requisitos previos respecto de la instalación de Python 3, por la cual se denomina al entorno virtual “my_env”. Sin embargo, podrá asignarle el nombre que desee.

      Comience activando el entorno virtual:

      • source my_env/bin/activate

      A continuación, su linea de comandos llevará como prefijo el nombre de su entorno.

      Ahora que se encuentra en su entorno virtual, instale Jupyter Notebook:

      • python3 -m pip install jupyter

      Si la instalación fue correcta, verá un resultado similar a este:

      Output

      . . . Successfully installed MarkupSafe-1.0 Send2Trash-1.5.0 backcall-0.1.0 bleach-2.1.3 decorator-4.3.0 entrypoints-0.2.3 html5lib-1.0.1 ipykernel-4.8.2 ipython-6.4.0 ipython-genutils-0.2.0 ipywidgets-7.2.1 jedi-0.12.0 jinja2-2.10 jsonschema-2.6.0 jupyter-1.0.0 jupyter-client-5.2.3 jupyter-console-5.2.0 jupyter-core-4.4.0 mistune-0.8.3 nbconvert-5.3.1 nbformat-4.4.0 notebook-5.5.0 pandocfilters-1.4.2 parso-0.2.0 pexpect-4.5.0 pickleshare-0.7.4 prompt-toolkit-1.0.15 ptyprocess-0.5.2 pygments-2.2.0 python-dateutil-2.7.3 pyzmq-17.0.0 qtconsole-4.3.1 simplegeneric-0.8.1 six-1.11.0 terminado-0.8.1 testpath-0.3.1 tornado-5.0.2

      Con esto, Jupyter Notebook quedará instalado en su servidor. A continuación, veremos la forma de ejecutar la aplicación.

      Paso 2: Ejecutar Jupyter Notebook

      Jupyter Notebook debe ejecutarse desde su VPS, de modo que pueda conectarse a ella desde su computadora local utilizando un túnerl SSH y su navegador web favorito.

      Para ejecutar el servidor Jupyter Notebook, instroduzca el siguiente comando:

      Después de ejecutar este comando, verá un resultado similar a este:

      Output

      [I 19:46:22.031 NotebookApp] Writing notebook server cookie secret to /home/sammy/.local/share/jupyter/runtime/notebook_cookie_secret [I 19:46:22.365 NotebookApp] Serving notebooks from local directory: /home/sammy/environments [I 19:46:22.365 NotebookApp] 0 active kernels [I 19:46:22.366 NotebookApp] The Jupyter Notebook is running at: [I 19:46:22.366 NotebookApp] http://localhost:8888/?token=Example_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675 [I 19:46:22.366 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation). [W 19:46:22.366 NotebookApp] No web browser found: could not locate runnable browser. [C 19:46:22.367 NotebookApp] Copy/paste this URL into your browser when you connect for the first time, to login with a token: http://localhost:8888/?token=Example_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675&tokenExample_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675

      Es posible que en el resultado observe una advertencia No web browser found. Esto es normal, ya que la aplicación se ejecuta en un servidor y probablemente no haya instalado en él un navegador web. A través de esta guía, verá la forma de conectarse a Notebook en el servidor utilizando túneles SSH en la siguiente sección.

      Por ahora, salga de Jupyter Notebook presionando CTRL+C e y, y luego utilice ENTER para confirmar:

      Output

      Shutdown this notebook server (y/[n])? y [C 20:05:47.654 NotebookApp] Shutdown confirmed [I 20:05:47.654 NotebookApp] Shutting down 0 kernels

      Luego, cierre el servidor con el comando exit:

      Ejecutó Jupyter Notebook en su servidor. Sin embargo, para acceder a la aplicación y comenzar a trabajar con notebooks, deberá conectarse a ella mediante túneles SSH y un navegador web en su computadora local.

      Los túneles SSH son una alternativa sencilla y rápida para conectarse a la aplicación Jupyter Notebook de su servidor. El shell seguro (más conocido como SSH) es un protocolo de red que le permite conectarse a un servidor remoto de forma segura a través de una red no protegida.

      El protocolo SSH incluye un mecanismo de enrutamiento de puerto que le permite canalizar algunas aplicaciones que se ejecutan en un número de puerto específico de un servidor a un número de puerto específico en su computadora local. Aprenderemos a “enrutar” de forma segura la aplicación Jupyter Notebook de su servidor (en el puerto 8888, por defecto) a un puerto de su computadora local.

      El método que utilice para establecer un túnel SSH dependerá del sistema operativo de su computadora local. Entre las subsecciones que se muestran a continuación,elija la que sea más pertinente para su computadora.

      Nota: Es posible configurar e instalar Jupyter Notebook utilizando DigitalOcean Web Console, pero la conexión a la aplicación mediante un túnel SSH debe realizarse a través del terminal o con PuTTY.

      Túneles SSH con macOS o Linux

      Si su computadora local tiene Linux o macOS instalado, es posible establecer un túnel SSH con un solo comando.

      ssh es el comando estándar para abrir una conexión SSH, pero cuando se utiliza con la directiva -L se puede especificar que un puerto determinado en el host local (es decir, su computadora local) se envíe a un host y un puerto determinados en el host remoto (en este caso, su servidor). Esto significa que lo que ejecute en el puerto especificado en el servidor remoto (8888, el puerto predeterminado de Jupyter Notebook) aparecerá en el puerto especificado en su computadora local (8000en el comando del ejemplo).

      Para establecer su propio túnel SSH, ejecute el siguiente comando. Puede cambiar el puerto 8000por uno de su elección si, por ejemplo, otro proceso utiliza el puerto 8000. Se le recomienda utilizar un puerto mayor o igual al 8000, ya que es improbable que otros procesos utilicen esos números de puertos. Asegúrese de incluir la dirección IP de su propio servidor y el nombre de su usuario no root del servidor:

      • ssh -L 8000:localhost:8888 sammy@your_server_ip

      Si no hay errores en este comando, accederá a su servidor remoto. Desde allí, active el entorno virtual:

      • source ~/environments/my_env/bin/activate

      Luego, ejecute la aplicación Jupyter Notebook:

      Para conectarse a Jupyter Notebook, utilice su navegador web favorito y diríjase al puerto local del host local: http://localhost:8000. Ahora que estableció conexión con Jupyter Notebook, continúe con el Paso 4 para aprender a utilizarla.

      Túneles SSH con Windows y PuTTY

      PuTTY es un cliente SSH de código abierto para Windows que puede utilizarse para conectarse a su servidor. Tras descargar e instalar PuTTY en su computadora con Windows (como se describe en el tutorial de los requisitos previos), abra el programa e introduzca la URL o la dirección IP de su servidor, como se muestra aquí:

      Introduzca la URL o IP del servidor en Putty

      A continuación, haga clic en + SSH en la parte inferior izquierda del panel y luego en Tunnels. En esta ventana, introduzca el puerto que desea utilizar para acceder a Jupyter en su computadora local (8000). Se le recomienda utilizar un puerto mayor o igual al 8000, ya que es improbable que otros procesos utilicen esos números de puertos. Si otro proceso utiliza el puerto 8000, seleccione un número de puerto diferente que no se haya utilizado. A continuación, establezca el destino como localhost:8888, ya que Jupyter Notebook funciona en el puerto 8888. Luego, haga clic en el botón Add. Deberían aparecer los puertos en el campo Forwarded ports:

      Configure el túnel SSH en Putty

      Por último, haga clic en el botón Open. Esto conectará su computadora al servidor a través de SSH y canalizará los puertos deseados. Si no aparecen errores, active su entorno virtual:

      • source ~/environments/my_env/bin/activate

      Luego, ejecute Jupyter Notebook:

      A continuación, diríjase al puerto local en su navegador web favorito, una opción puede ser http://localhost:8000 (o cualquier número de puerto que haya elegido), para establecer conexión con la instancia de Jupyter Notebook del servidor. Ahora que estableció conexión con Jupyter Notebook, continúe con el Paso 4 para aprender a utilizarla.

      Paso 4: Usar Jupyter Notebook

      Cuando se accede a través de un navegador web, Jupyter Notebook proporciona un panel de notebooks que funciona como navegador de archivos y le proporciona una interfaz para crear, editar y explorar notebooks. Considere estos notebooks como documentos (guardados con una extensión de archivo .ipynb) que usted puede llenar con cualquier número de celdas individuales. Cada celda tiene un editor de texto interactivo que puede utilizarse para ejecutar código o escribir texto representado. Además, los notebooks le permiten escribir y ejecutar ecuaciones e incluir otros medios, como imágenes o tramas interactivas. También se pueden exportar y compartir en varios formatos (.ipyb, .pdf, .py). Para mostrar algunas de estas funciones, crearemos un archivo notebook desde el panel de notebooks, escribiremos una tabla de texto sencilla con una ecuación y ejecutaremos código básico de Python 3.

      En este punto, deberá estar conectado al servidor a través de un túnel SSH y haber iniciado la aplicación Jupyter Notebook desde su servidor. Una vez que se dirija a http://localhost:8000, verá aparecer una página de inicio de sesión:

      Pantalla de inicio de sesión de Jupyter Notebook

      En el campo Password or token de la parte superior, introduzca el token que vio aparecer en el resultado después de ejecutar jupyter notebook desde su servidor:

      Output

      [I 20:35:17.004 NotebookApp] Writing notebook server cookie secret to /run/user/1000/jupyter/notebook_cookie_secret [I 20:35:17.314 NotebookApp] Serving notebooks from local directory: /home/sammy [I 20:35:17.314 NotebookApp] 0 active kernels [I 20:35:17.315 NotebookApp] The Jupyter Notebook is running at: [I 20:35:17.315 NotebookApp] http://localhost:8888/?token=Example_Jupyter_Token_3cadb8b8b7005d9a46ca4d6675 [I 20:35:17.315 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation). [W 20:35:17.315 NotebookApp] No web browser found: could not locate runnable browser. [C 20:35:17.316 NotebookApp] . . .

      También puede copiar esa URL del resultado de su terminal y pegarla en la barra de direcciones de su navegador.

      De forma automática, Jupyter notebook mostrará los archivos y las carpetas almacenados en el directorio desde el que se ejecuta. Cree un nuevo archivo notebook haciendo clic en New y luego en Python 3 en la parte superior derecha del panel de notebooks:

      Cree un nuevo notebook de Python3

      Dentro de este nuevo notebook, cambie la primera celda para aceptar sintaxis de lenguaje de marcado presionando Cell > Cell Type > Markdown en la barra de navegación de la parte superior. Esta categoría “Cell Type” también le permite escribir ecuaciones en LaTeX además de usar lenguaje de marcado. Por ejemplo, escriba lo siguiente en la celda después del cambio a lenguaje de marcado:

      # Simple Equation
      
      Let us now implement the following equation in Python:
      $$ y = x^2$$
      
      where $x = 2$
      

      Para convertir el lenguaje de marcado en texto enriquecido, presione CTRL + ENTER. Debería aparecer el siguiente resultado:

      Convierta la ecuación de ejemplo en texto enriquecido

      Puede utilizar las celdas de lenguaje de marcado para crear notas y documentar su código.

      Ahora, implementaremos una ecuación sencilla y mostraremos el resultado. Haga clic en Insert *> *Insert Cell Below para insertar una celda. En esta nueva celda, introduzca el siguiente código:

      x = 2
      y = x*x
      print(y)
      

      Para ejecutar el código, presione CTRL + ENTER. Se mostrará el siguiente resultado:

      Resuelva la ecuación de muestra

      Estos son algunos ejemplos relativamente sencillos de lo que puede hacer con Jupyter Notebook. Sin embargo, es una aplicación muy potente que puede implementarse en muchos casos de uso. Desde aquí, puede agregar algunas bibliotecas de Python y utilizar el notebook como haría con cualquier otro entorno de desarrollo de Python.

      Conclusión

      Ahora, debería poder escribir código y texto reproducible de Python utilizando Jupyter Notebook en un servidor remoto. Para ver rápidamente Jupyter Notebook, haga clic en Help en la barra de navegación superior y seleccione User Interface Tour, como se muestra aquí:

      Encontrar el recorrido de la ayuda de Jupyter Notebook

      Si le interesa, le sugerimos obtener más información sobre Jupyter Notebook consultando la documentación de Project Jupyter. Además, puede aprovechar lo que aprendió en este tutorial aprendiendo a codificar en Python 3.



      Source link

      How To Set Up a Jupyter Notebook with Python 3 on Debian 10


      Introduction

      Jupyter Notebook offers a command shell for interactive computing as a web application so that you can share and communicate with code. The tool can be used with several languages, including Python, Julia, R, Haskell, and Ruby. It is often used for working with data, statistical modeling, and machine learning.

      This tutorial will walk you through setting up Jupyter Notebook to run from a Debian 10 server, as well as teach you how to connect to and use the Notebook. Jupyter Notebooks (or just “Notebooks”) are documents produced by the Jupyter Notebook app which contain both computer code and rich text elements (paragraph, equations, figures, links, etc.) which aid in presenting and sharing reproducible research.

      By the end of this guide, you will be able to run Python 3 code using Jupyter Notebook running on a remote Debian 10 server.

      Prerequisites

      In order to complete this guide, you should have a fresh Debian 10 server instance with a basic firewall and a non-root user with sudo privileges configured. You can learn how to set this up by running through our Initial Server Setup with Debian 10 guide.

      Step 1 — Install Pip and Python Headers

      To begin the process, we’ll download and install all of the items we need from the Debian repositories. We will use the Python package manager pip to install additional components a bit later.

      We first need to update the local apt package index and then download and install the packages:

      Next, install pip and the Python header files, which are used by some of Jupyter’s dependencies:

      • sudo apt install python3-pip python3-dev

      Debian 10 (“Buster”) comes preinstalled with Python 3.7.

      We can now move on to setting up a Python virtual environment into which we’ll install Jupyter.

      Step 2 — Create a Python Virtual Environment for Jupyter

      Now that we have Python 3, its header files, and pip ready to go, we can create a Python virtual environment for easier management. We will install Jupyter into this virtual environment.

      To do this, we first need access to the virtualenv command. We can install this with pip.

      Upgrade pip and install the package by typing:

      • sudo -H pip3 install --upgrade pip
      • sudo -H pip3 install virtualenv

      With virtualenv installed, we can start forming our environment. Create and move into a directory where we can keep our project files:

      • mkdir ~/myprojectdir
      • cd ~/myprojectdir

      Within the project directory, create a Python virtual environment by typing:

      This will create a directory called myprojectenv within your myprojectdir directory. Inside, it will install a local version of Python and a local version of pip. We can use this to install and configure an isolated Python environment for Jupyter.

      Before we install Jupyter, we need to activate the virtual environment. You can do that by typing:

      • source myprojectenv/bin/activate

      Your prompt should change to indicate that you are now operating within a Python virtual environment. It will look something like this: (myprojectenv)user@host:~/myprojectdir$.

      You’re now ready to install Jupyter into this virtual environment.

      Step 3 — Install Jupyter

      With your virtual environment active, install Jupyter with the local instance of pip:

      Note: When the virtual environment is activated (when your prompt has (myprojectenv) preceding it), use pip instead of pip3, even if you are using Python 3. The virtual environment’s copy of the tool is always named pip, regardless of the Python version.

      At this point, you’ve successfully installed all the software needed to run Jupyter. We can now start the Notebook server.

      Step 4 — Run Jupyter Notebook

      You now have everything you need to run Jupyter Notebook! To run it, execute the following command:

      A log of the activities of the Jupyter Notebook will be printed to the terminal. When you run Jupyter Notebook, it runs on a specific port number. The first Notebook you run will usually use port 8888. To check the specific port number Jupyter Notebook is running on, refer to the output of the command used to start it:

      Output

      [I 21:23:21.198 NotebookApp] Writing notebook server cookie secret to /run/user/1001/jupyter/notebook_cookie_secret [I 21:23:21.361 NotebookApp] Serving notebooks from local directory: /home/sammy/myprojectdir [I 21:23:21.361 NotebookApp] The Jupyter Notebook is running at: [I 21:23:21.361 NotebookApp] http://localhost:8888/?token=1fefa6ab49a498a3f37c959404f7baf16b9a2eda3eaa6d72 [I 21:23:21.361 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation). [W 21:23:21.361 NotebookApp] No web browser found: could not locate runnable browser. [C 21:23:21.361 NotebookApp] Copy/paste this URL into your browser when you connect for the first time, to login with a token: http://localhost:8888/?token=1fefa6ab49a498a3f37c959404f7baf16b9a2eda3eaa6d72

      If you are running Jupyter Notebook on a local Debian computer (not on a Droplet), you can simply navigate to the displayed URL to connect to Jupyter Notebook. If you are running Jupyter Notebook on a Droplet, you will need to connect to the server using SSH tunneling as outlined in the next section.

      At this point, you can keep the SSH connection open and keep Jupyter Notebook running or can exit the app and re-run it once you set up SSH tunneling. Let’s keep it simple and stop the Jupyter Notebook process. We will run it again once we have SSH tunneling working. To stop the Jupyter Notebook process, press CTRL+C, type Y, and hit ENTER to confirm. The following will be displayed:

      Output

      [C 21:28:28.512 NotebookApp] Shutdown confirmed [I 21:28:28.512 NotebookApp] Shutting down 0 kernels

      We’ll now set up an SSH tunnel so that we can access the Notebook.

      Step 5 — Connect to the Server Using SSH Tunneling

      In this section we will learn how to connect to the Jupyter Notebook web interface using SSH tunneling. Since Jupyter Notebook will run on a specific port on the server (such as :8888, :8889 etc.), SSH tunneling enables you to connect to the server’s port securely.

      The next two subsections describe how to create an SSH tunnel from 1) a Mac or Linux and 2) Windows. Please refer to the subsection for your local computer.

      SSH Tunneling with a Mac or Linux

      If you are using a Mac or Linux, the steps for creating an SSH tunnel are similar to using SSH to log in to your remote server, except that there are additional parameters in the ssh command. This subsection will outline the additional parameters needed in the ssh command to tunnel successfully.

      SSH tunneling can be done by running the following SSH command in a new local terminal window:

      • ssh -L 8888:localhost:8888 your_server_username@your_server_ip

      The ssh command opens an SSH connection, but -L specifies that the given port on the local (client) host is to be forwarded to the given host and port on the remote side (server). This means that whatever is running on the second port number (e.g. 8888) on the server will appear on the first port number (e.g. 8888) on your local computer.

      Optionally change port 8888 to one of your choosing to avoid using a port already in use by another process.

      server_username is your username (e.g. sammy) on the server which you created and your_server_ip is the IP address of your server.

      For example, for the username sammy and the server address 203.0.113.0, the command would be:

      • ssh -L 8888:localhost:8888 sammy@203.0.113.0

      If no error shows up after running the ssh -L command, you can move into your programming environment and run Jupyter Notebook:

      You’ll receive output with a URL. From a web browser on your local machine, open the Jupyter Notebook web interface with the URL that starts with http://localhost:8888. Ensure that the token number is included, or enter the token number string when prompted at http://localhost:8888.

      SSH Tunneling with Windows and Putty

      If you are using Windows, you can create an SSH tunnel using Putty.

      First, enter the server URL or IP address as the hostname as shown:

      Set Hostname for SSH Tunnel

      Next, click SSH on the bottom of the left pane to expand the menu, and then click Tunnels. Enter the local port number to use to access Jupyter on your local machine. Choose 8000 or greater to avoid ports used by other services, and set the destination as localhost:8888 where :8888 is the number of the port that Jupyter Notebook is running on.

      Now click the Add button, and the ports should appear in the Forwarded ports list:

      Forwarded ports list

      Finally, click the Open button to connect to the server via SSH and tunnel the desired ports. Navigate to http://localhost:8000 (or whatever port you chose) in a web browser to connect to Jupyter Notebook running on the server. Ensure that the token number is included, or enter the token number string when prompted at http://localhost:8000.

      Step 6 — Using Jupyter Notebook

      This section goes over the basics of using Jupyter Notebook. If you don’t currently have Jupyter Notebook running, start it with the jupyter notebook command.

      You should now be connected to it using a web browser. Jupyter Notebook is a very powerful tool with many features. This section will outline a few of the basic features to get you started using the Notebook. Jupyter Notebook will show all of the files and folders in the directory it is run from, so when you’re working on a project make sure to start it from the project directory.

      To create a new Notebook file, select New > Python 3 from the top right pull-down menu:

      Create a new Python 3 notebook

      This will open a Notebook. We can now run Python code in the cell or change the cell to markdown. For example, change the first cell to accept Markdown by clicking Cell > Cell Type > Markdown from the top navigation bar. We can now write notes using Markdown and even include equations written in LaTeX by putting them between the $$ symbols. For example, type the following into the cell after changing it to markdown:

      # First Equation
      
      Let us now implement the following equation:
      $$ y = x^2$$
      
      where $x = 2$
      

      To turn the markdown into rich text, press CTRL+ENTER, and the following should be the results:

      results of markdown

      You can use the markdown cells to make notes and document your code. Let’s implement that equation and print the result. Click on the top cell, then press ALT+ENTER to add a cell below it. Enter the following code in the new cell.

      x = 2
      y = x**2
      print(y)
      

      To run the code, press CTRL+ENTER. You’ll receive the following results:

      first equation results

      You now have the ability to import modules and use the Notebook as you would with any other Python development environment!

      Conclusion

      At this point, you should be able to write reproducible Python code and notes in Markdown using Jupyter Notebook. To get a quick tour of Jupyter Notebook from within the interface, select Help > User Interface Tour from the top navigation menu to learn more.

      From here, you can begin a data analysis and visualization project by reading Data Analysis and Visualization with pandas and Jupyter Notebook in Python 3.



      Source link

      Como Configurar o Jupyter Notebook com Python 3 no Ubuntu 18.04


      Introdução

      O Jupyter Notebook é uma aplicação web open-source que lhe permite criar e compartilhar código interativo, visualizações e muito mais. Esta ferramenta pode ser usada com várias linguagens de programação, incluindo Python, Julia, R, Haskell e Ruby. Ele é frequentemente usado para trabalhar com dados, modelagem estatística e aprendizado de máquina.

      Este tutorial irá orientá-lo na configuração do Jupyter Notebook para ser executado em um servidor Ubuntu 18.04, além de ensinar como se conectar e usar o notebook. Jupyter Notebooks (ou simplesmente Notebooks) são documentos produzidos pelo aplicativo Jupyter Notebook, que contém tanto código de computador quanto elementos de rich text (parágrafos, equações, figuras, links, etc.) que ajudam a apresentar e compartilhar pesquisas reproduzíveis.

      Ao final deste guia, você será capaz de executar código Python 3 usando o Jupyter Notebook em execução em um servidor remoto.

      Pré-requisitos

      Para completar este guia, você deve ter uma nova instância de servidor Ubuntu 18.04, configurado com um firewall básico e um usuário não-root com privilégios sudo. Você pode aprender como configurar isso através de nosso tutorial de configuração inicial de servidor.

      Passo 1 — Configurar o Python

      Para começar o processo, vamos instalar as dependências que precisamos para o nosso ambiente de programação Python a partir dos repositórios do Ubuntu. O Ubuntu 18.04 vem pré-instalado com o Python 3.6. Vamos utilizar o gerenciador de pacotes Python, pip, para instalar componentes adicionais um pouco mais tarde.

      Primeiro precisamos atualizar o índice local de pacotes do apt e depois baixar e instalar os pacotes:

      Em seguida, instale o pip e os arquivos de cabeçalho do Python, que são utilizados por algumas das dependências do Jupyter:

      • sudo apt install python3-pip python3-dev

      Podemos passar agora a configurar um ambiente virtual Python no qual instalaremos o Jupyter.

      Passo 2 — Criar um Ambiente Virtual do Python para o Jupyter

      Agora que temos o Python 3, seus arquivos de cabeçalho e o pip pronto para usar, podemos criar um ambiente virtual Python para gerenciar nossos projetos. Vamos instalar o Jupyter neste ambiente virtual.

      Para fazer isso, primeiro precisamos acessar o comando virtualenv, que podemos instalar com o pip.

      Atualize o pip e instale o pacote digitando:

      • sudo -H pip3 install --upgrade pip
      • sudo -H pip3 install virtualenv

      A flag -H garante que a política de segurança configure a variável de ambiente home para o diretório home do usuário de destino.

      Com o virtualenv instalado, podemos começar a formar nosso ambiente. Crie e mova-se para um diretório onde possamos manter nossos arquivos de projeto. Chamaremos o nosso de meu_projeto, mas você pode usar um nome que seja significativo para você e no qual você esteja trabalhando.

      • mkdir ~/meu_projeto
      • cd ~/meu_projeto

      Dentro do diretório do projeto, criaremos um ambiente virtual do Python. Para o propósito deste tutorial, vamos chamá-lo de meu_projeto_env, mas você pode chamá-lo de algo que seja relevante para o seu projeto.

      • virtualenv meu_projeto_env

      Isso irá criar um diretório chamado meu_projeto_env dentro do diretório meu_projeto. Dentro, ele instalará uma versão local do Python e uma versão local do pip. Podemos usar isso para instalar e configurar um ambiente Python isolado para o Jupyter.

      Antes de instalarmos o Jupyter, precisamos ativar o ambiente virtual. Você pode fazer isso digitando:

      • source meu_projeto_env/bin/activate

      Seu prompt deve mudar para indicar que você agora está operando dentro de um ambiente virtual do Python. Vai parecer algo assim: (meu_projeto_env)usuário@host:~/meu_projeto$.

      Agora você está pronto para instalar o Jupyter nesse ambiente virtual.

      Passo 3 — Instalar o Jupyter

      Com o seu ambiente virtual ativo, instale o Jupyter com a instância local do pip.

      Nota: Quando o ambiente virtual está ativado (quando o seu prompt tem (meu_projeto_env) precedendo-o), usepip em vez de pip3, mesmo se você estiver usando o Python 3. A cópia do ambiente virtual da ferramenta é sempre denominada pip, independentemente da versão do Python.

      Neste ponto, você instalou com sucesso todo o software necessário para executar o Jupyter. Agora podemos iniciar o servidor do Notebook.

      Passo 4 — Executar o Jupyter Notebook

      Agora você tem tudo o que precisa para rodar o Jupyter Notebook! Para executá-lo, execute o seguinte comando:

      Um registro das atividades do Jupyter Notebook será impresso no terminal. Quando você executa o Jupyter Notebook, ele é executado em um número de porta específico. O primeiro Notebook que você executa geralmente usa a porta 8888. Para verificar o número de porta específico em que o Jupyter Notebook está sendo executado, consulte a saída do comando usado para iniciá-lo:

      Output

      [I 21:23:21.198 NotebookApp] Writing notebook server cookie secret to /run/user/1001/jupyter/notebook_cookie_secret [I 21:23:21.361 NotebookApp] Serving notebooks from local directory: /home/sammy/meu_projeto [I 21:23:21.361 NotebookApp] The Jupyter Notebook is running at: [I 21:23:21.361 NotebookApp] http://localhost:8888/?token=1fefa6ab49a498a3f37c959404f7baf16b9a2eda3eaa6d72 [I 21:23:21.361 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation). [W 21:23:21.361 NotebookApp] No web browser found: could not locate runnable browser. [C 21:23:21.361 NotebookApp] Copy/paste this URL into your browser when you connect for the first time, to login with a token: http://localhost:8888/?token=1fefa6ab49a498a3f37c959404f7baf16b9a2eda3eaa6d72

      Se você estiver executando o Jupyter Notebook em um computador local (não em um servidor), poderá navegar até a URL exibida para se conectar ao Jupyter Notebook. Se você estiver executando o Jupyter Notebook em um servidor, será necessário conectar-se ao servidor usando o tunelamento SSH, conforme descrito na próxima seção.

      Neste ponto, você pode manter a conexão SSH aberta e manter o Jupyter Notebook em execução ou sair do aplicativo e executá-lo novamente assim que configurar o tunelamento SSH. Vamos escolher parar o processo do Jupyter Notebook. Vamos executá-lo novamente assim que tivermos o tunelamento SSH configurado. Para parar o processo do Jupyter Notebook, pressione CTRL+C, digite Y e, em seguida, ENTER para confirmar. A seguinte saída será mostrada:

      Output

      [C 21:28:28.512 NotebookApp] Shutdown confirmed [I 21:28:28.512 NotebookApp] Shutting down 0 kernels

      Agora, vamos configurar um túnel SSH para que possamos acessar o Notebook.

      Passo 5 - Conectar ao Servidor Usando o Tunelamento SSH

      Nesta seção, aprenderemos como conectar-se à interface web do Jupyter Notebook usando o tunelamento SSH. Como o Jupyter Notebook será executado em uma porta específica no servidor (tais como :8888, :8889 etc.), o tunelamento SSH permite que você se conecte à porta do servidor com segurança.

      As próximas duas subseções descrevem como criar um túnel SSH a partir de 1) um Mac ou Linux e 2) Windows. Por favor, consulte a subseção para o seu computador local.

      Tunelamento SSH com um Mac ou Linux

      Se você estiver usando um Mac ou Linux, as etapas para criar um túnel SSH são semelhantes ao uso do SSH para efetuar login no seu servidor remoto, exceto que existem parâmetros adicionais no comando ssh. Esta subseção descreverá os parâmetros adicionais necessários no comando ssh para fazer um túnel com sucesso.

      O tunelamento SSH pode ser feito executando o seguinte comando SSH em uma nova janela de terminal local:

      • ssh -L 8888:localhost:8888 usuário_do_servidor@ip_do_seu_servidor

      O comando ssh abre uma conexão SSH, mas -L especifica que a porta no host local (cliente) deve ser encaminhada para o host e porta no lado remoto (servidor). Isso significa que, o que quer que esteja rodando no segundo número de porta (ex: 8888) no servidor aparecerá no primeiro número de porta (ex: 8888) em seu computador local.

      Opcionalmente, altere a porta 8888 para uma de sua escolha, para evitar o uso de uma porta que já esteja em uso por outro processo.

      usuário_do_servidor é o seu usuário (ex: sammy) no servidor que você criou, e ip_do_seu_servidor é o endereço IP do seu servidor.

      Por exemplo, para o usuário sammy e o endereço de servidor 203.0.113.0, o comando seria:

      • ssh -L 8888:localhost:8888 sammy@203.0.113.0

      Se nenhum erro aparecer depois de executar o comando ssh -L, você pode entrar em seu ambiente de programação e executar o Jupyter Notebook:

      Você receberá uma saída com uma URL. Em um navegador web em sua máquina local, abra a interface web do Jupyter Notebook com a URL que começa com http://localhost:8888. Assegure-se de que o número do token esteja incluído ou insira a string do número do token quando solicitado em http://localhost:8888.

      Tunelamento SSH com Windows e Putty

      Se você estiver usando o Windows, poderá criar um túnel SSH usando o Putty.

      Primeiro, insira a URL do servidor ou o endereço IP como o nome do host, como mostrado:

      Em seguida, clique em SSH na parte inferior do painel esquerdo para expandir o menu e, em seguida, clique em Tunnels. Digite o número da porta local que você deseja usar para acessar o Jupyter em sua máquina local. Escolha 8000 ou superior para evitar portas usadas por outros serviços, e defina o destino como localhost:8888 onde :8888 é o número da porta na qual o Jupyter Notebook está sendo executado.

      Agora, clique no botão Add, e as portas deverão aparecer na lista Forwarded ports

      Por fim, clique no botão Open para conectar-se ao servidor via SSH e tunelar as portas desejadas. Navegue até http://localhost:8000 (ou qualquer porta que você escolheu) em um navegador da web para se conectar ao Jupyter Notebook em execução no servidor. Assegure-se de que o número do token esteja incluído ou insira a string do número do token quando solicitado em http://localhost:8000.

      Passo 6 — Usando o Jupyter Notebook

      Esta seção aborda os conceitos básicos do uso do Jupyter Notebook. Se você ainda não tem o Jupyter Notebook em execução, inicie-o com o comando jupyter notebook.

      Agora você deve estar conectado a ele usando um navegador web. O Jupyter Notebook é uma ferramenta muito poderosa com muitos recursos. Esta seção descreverá alguns dos recursos básicos para você começar a usar o Notebook. O Jupyter Notebook mostrará todos os arquivos e pastas no diretório a partir do qual ele é executado. Portanto, quando você estiver trabalhando em um projeto, certifique-se de iniciá-lo no diretório do projeto.

      Para criar um novo arquivo do Notebook, selecione New > Python 3 no menu suspenso superior direito:

      Isso irá abrir um Notebook. Agora podemos executar o código Python na célula ou alterar a célula para markdown. Por exemplo, altere a primeira célula para aceitar Markdown clicando em Cell > Cell Type > Markdown na barra de navegação superior. Agora podemos escrever notas usando Markdown e até incluir equações escritas em LaTeX colocando-as entre os símbolos $$. Por exemplo, digite o seguinte na célula depois de alterá-la para markdown:

      # Primeira Equação
      
      Vamos agora implementar a seguinte equação:
      $$ y = x^2$$
      
      Onde $x = 2$
      

      Para transformar o markdown em rich text, pressione CTRL+ENTER, e o resultado deve ser o seguinte:

      Você pode usar as células markdown para fazer anotações e documentar seu código. Vamos implementar essa equação e imprimir o resultado. Clique na célula superior e pressione ALT+ENTER para adicionar uma célula abaixo dela. Digite o seguinte código na nova célula.

      x = 2
      y = x**2
      print(y)
      

      Para executar o código, pressione CTRL+ENTER. Você receberá os seguintes resultados:

      Agora você tem a capacidade de importar modulos e usar o Notebook como você faria com qualquer outro ambiente de desenvolvimento Python!

      Conclusão

      Parabéns! Agora você deve ser capaz de escrever códigos reproduzíveis em Python e notas no Markdown usando o Jupyter Notebook. Para obter um tour rápido pelo Jupyter Notebook dentro da interface, selecione Help > User Interface Tour no menu de navegação superior para saber mais.

      A partir daqui, você pode iniciar um projeto de análise e visualização de dados lendo Data Analysis and Visualization with pandas and Jupyter Notebook in Python 3.

      Se você tem interesse em pesquisar mais, leia nossa série sobre Visualização e Previsão de Séries Temporais.

      Por Lisa Tagliaferri



      Source link