One place for hosting & domains

      Conectar

      Como usar o SSH para se conectar a um servidor remoto


      Introdução

      Uma ferramenta essencial para se ter domínio na administração de sistemas é o SSH.

      O SSH, ou Secure Shell, é um protocolo usado para fazer login em sistemas remotos de forma segura. É a maneira mais comum de acessar servidores Linux remotos.

      Neste guia, vamos discutir como usar o SSH para se conectar a um sistema remoto.

      Sintaxe básica

      Para se conectar a um sistema remoto usando o SSH, vamos usar o comando ssh. A forma mais básica do comando é:

      O remote_host neste exemplo é o endereço IP ou o nome de domínio ao qual você está tentando se conectar.

      Este comando assume que o nome de usuário no sistema remoto é o mesmo que o seu nome de usuário em seu sistema local.

      Se o nome de usuário for diferente no sistema remoto, especifique isso usando esta sintaxe:

      • ssh remote_username@remote_host

      Depois de se conectar ao servidor, será solicitado que verifique sua identidade fornecendo uma senha. Mais tarde, vamos mostrar como gerar chaves para usar em vez de senhas.

      Para sair da sessão ssh e retornar em sua sessão de shell local, digite:

      Como o SSH funciona?

      O SSH funciona conectando um programa cliente a um servidor ssh, chamado sshd.

      Na seção anterior, o ssh era o programa cliente. O servidor ssh já está sendo executado no remote_host que especificamos.

      Em seu servidor, o servidor sshd já deve estar sendo executado. Se este não for o caso, será necessário acessar seu servidor através de um console baseado na Web ou console serial local.

      O processo necessário para iniciar um servidor ssh depende da distribuição Linux que você está usando.

      No Ubuntu, inicie o servidor ssh digitando:

      Isso deve iniciar o servidor sshd e então você pode fazer login remotamente.

      Como configurar o SSH

      Quando você altera a configuração do SSH, está alterando as configurações do servidor sshd.

      No Ubuntu, o arquivo de configuração sshd principal está localizado em /etc/ssh/sshd_config.

      Faça o backup da versão atual deste arquivo antes de editar:

      • sudo cp /etc/ssh/sshd_config{,.bak}

      Abra-o com um editor de texto:

      • sudo nano /etc/ssh/sshd_config

      Você vai querer deixar a maioria das opções neste arquivo sozinha. No entanto, existem algumas que você pode querer dar uma olhada:

      /etc/ssh/sshd_config

      Port 22
      

      A declaração port especifica em qual porta o servidor sshd irá ouvir conexões. Por padrão, ela é a 22. Você provavelmente deve deixar essa configuração intacta, a menos que tenha motivos específicos para fazer o contrário. Se você alterar sua porta, vamos mostrar a você como se conectar à nova porta posteriormente.

      /etc/ssh/sshd_config

      HostKey /etc/ssh/ssh_host_rsa_key
      HostKey /etc/ssh/ssh_host_dsa_key
      HostKey /etc/ssh/ssh_host_ecdsa_key
      

      As declarações HostKey especificam onde procurar por chaves host globais. Vamos discutir o que é uma chave host mais tarde.

      /etc/ssh/sshd_config

      SyslogFacility AUTH
      LogLevel INFO
      

      Esses dois itens indicam o nível de geração de registros que deve ocorrer.

      Se você estiver tendo dificuldades com o SSH, aumentar a quantidade de registros pode ser uma boa maneira de descobrir qual é o problema.

      /etc/ssh/sshd_config

      LoginGraceTime 120
      PermitRootLogin yes
      StrictModes yes
      

      Esses parâmetros especificam algumas das informações de login.

      LoginGraceTime especifica por quantos segundos será mantida a conexão sem fazer o login com sucesso.

      Pode ser uma boa ideia definir esse tempo apenas um pouco mais alto do que a quantidade de tempo que você leva para fazer login normalmente.

      PermitRootLogin seleciona se o usuário root está autorizado a fazer login.

      Na maioria dos casos, isso deve ser alterado para no quando você criou uma conta de usuário que tem acesso a privilégios elevados (através de su ou sudo) e pode fazer login via ssh.

      strictModes é uma proteção de segurança que recusará uma tentativa de login se os arquivos de autenticação puderem ser lidos por todos.

      Isso impede tentativas de login quando os arquivos de configuração não estão seguros.

      /etc/ssh/sshd_config

      X11Forwarding yes
      X11DisplayOffset 10
      

      Esses parâmetros configuram uma habilidade chamada X11 Forwarding. Isso permite que você visualize a interface gráfica de usuário (GUI) de um sistema remoto, no sistema local.

      Essa opção deve estar habilitada no servidor e enviada com o cliente SSH durante a conexão com a opção -X.

      Depois de fazer as alterações, salve e feche o arquivo digitando CTRL+X e Y, seguido por ENTER.

      Se você alterou quaisquer configurações em /etc/ssh/sshd_config, certifique-se de recarregar o servidor sshd para implementar suas modificações:

      • sudo systemctl reload ssh

      Você deve testar suas alterações minuciosamente para garantir que elas operem da forma que você espera.

      Pode ser uma boa ideia ter algumas sessões ativas quando você estiver fazendo alterações. Isso permitirá que você reverta a configuração se necessário.

      Embora seja útil fazer login em um sistema remoto usando senhas, é uma ideia muito melhor configurar a autenticação baseada em chaves.

      Como a autenticação baseada em chaves funciona?

      A autenticação baseada em chaves funciona criando um par de chaves: uma chave privada e uma chave pública.

      A chave privada está localizada na máquina cliente e é protegida e mantida em segredo.

      A chave pública pode ser fornecida a qualquer um ou colocada em qualquer servidor que você queira acessar.

      Quando você tentar se conectar usando um par de chaves, o servidor usará a chave pública para criar uma mensagem para o computador cliente que só pode ser lida com a chave privada.

      O computador cliente então envia a resposta adequada de volta ao servidor e o servidor saberá que o cliente é legítimo.

      Todo esse processo é feito automaticamente depois de você configurar as chaves.

      Como criar chaves SSH

      As chaves SSH devem ser geradas no computador a partir do qual você deseja fazer login. Esta é geralmente a sua máquina local.

      Digite o seguinte na linha de comando:

      Pressione enter para aceitar os padrões. Suas chaves serão criadas em ~/.ssh/id_rsa.pub e ~/.ssh/id_rsa.

      Mude para o diretório .ssh digitando:

      Olhe para as permissões dos arquivos:

      Output

      -rw-r--r-- 1 demo demo 807 Sep 9 22:15 authorized_keys -rw------- 1 demo demo 1679 Sep 9 23:13 id_rsa -rw-r--r-- 1 demo demo 396 Sep 9 23:13 id_rsa.pub

      Como você pode ver, o arquivo id_rsa é legível e gravável apenas pelo proprietário. É assim que deve ser para mantê-lo em segredo.

      O arquivo id_rsa.pub, no entanto, pode ser compartilhado e possui permissões adequadas para essa atividade.

      Como transferir sua chave pública para o servidor

      Se você tiver atualmente acesso baseado em senha a um servidor, você pode copiar sua chave pública para ele executando este comando:

      Isso irá iniciar uma sessão SSH. Depois de inserir sua senha, ele irá copiar sua chave pública para o arquivo de chaves autorizadas do servidor, o que permitirá que você faça login sem a senha da próxima vez.

      Opções do lado do cliente

      Existem vários sinalizadores opcionais que você pode selecionar ao se conectar por meio de SSH.

      Alguns deles podem ser necessários para corresponder às definições na configuração sshd do host remoto.

      Por exemplo, se você alterou o número de porta em sua configuração sshd, você precisará fazer a correspondência dessa porta do lado do cliente digitando:

      • ssh -p port_number remote_host

      Se você deseja apenas executar um único comando em um sistema remoto, especifique-o após o host dessa forma:

      • ssh remote_host command_to_run

      Você irá se conectar à máquina remota, autenticar, e o comando será executado.

      Como dissemos antes, se o encaminhamento X11 estiver habilitado em ambos os computadores, acesse essa funcionalidade digitando:

      Desde que você tenha as ferramentas apropriadas em seu computador, programas gráficos que você usa no sistema remoto irão agora abrir suas janelas em seu sistema local.

      Desativando a autenticação de senha

      Se você criou chaves SSH, melhore a segurança do seu servidor desativando a autenticação somente de senhas. Além do console, a única maneira de fazer login no servidor será através da chave privada que emparelha com a chave pública que você instalou no servidor.

      Aviso: antes de prosseguir com este passo, certifique-se de que você instalou uma chave pública no servidor. Caso contrário, você estará sob bloqueio!

      Como root ou usuário com privilégios sudo, abra o arquivo de configuração sshd:

      • sudo nano /etc/ssh/sshd_config

      Localize a linha em que se lê Password Authentication, e descomente-a removendo o # do início. Em seguida, altere seu valor para no:

      /etc/ssh/sshd_config

      PasswordAuthentication no
      

      Duas outras configurações que não devem precisar ser modificadas (desde que você não tenha modificado este arquivo antes) são PubkeyAuthentication e ChallengeResponseAuthentication. Elas são definidas por padrão, e devem estar da seguinte forma:

      /etc/ssh/sshd_config

      PubkeyAuthentication yes
      ChallengeResponseAuthentication no
      

      Depois de fazer as alterações, salve e feche o arquivo.

      Agora, é possível recarregar o daemon SSH:

      • sudo systemctl reload ssh

      A autenticação de senha agora deve estar desativada e o servidor deve estar acessível apenas através da autenticação de chaves SSH.

      Conclusão

      Aprender como usar o SSH é uma atividade que vale a pena, mesmo porque é uma atividade muito comum.

      Ao usar as várias opções, você descobrirá funcionalidades mais avançadas que podem tornar sua vida mais fácil. O SSH permaneceu popular porque é seguro, leve e útil em diversas situações.



      Source link

      Cómo configurar Jupyter Notebook con Python 3 en Ubuntu 20.04 y conectar a través de los túneles SSH


      Introducción

      Jupyter Notebook es una aplicación web de código abierto que le permite crear y compartir código interactivo, visualizaciones y mucho más. Esta herramienta puede utilizarse con varios lenguajes de programación, como Python, Julia, R, Haskell y Ruby. A menudo se utiliza para trabajar con datos, modelos estadísticos, y aprendizaje automático.

      Jupyter Notebooks (o simplemente “Notebooks”) es un conjunto de documentos producidos por la aplicación Jupyter Notebook, la cual contiene tanto elementos de código informático como de texto enriquecido (párrafos, ecuaciones, cifras y enlaces, entre otros) que ayudan a presentar y compartir la investigación que puede reproducirse. Por tanto, puede ser una herramienta excelente para las presentaciones basadas en datos o basadas en programación, o como herramienta de enseñanza.

      Este tutorial mostrará cómo configurar Jupyter Notebook para que se ejecute desde un servidor Ubuntu 20.04, y demostrará cómo conectar y usar Notebook desde un equipo local a través de la tunelación. Al final de esta guía, podrá ejecutar código de Python 3 usando un Jupyter Notebook en ejecución en un servidor remoto.

      Requisitos previos

      Para completar esta guía, debe disponer de una instancia de servidor de Ubuntu 20.04 nueva con un firewall básico y un usuario no root con privilegios sudo configurados. Puede aprender a configurar esto en nuestro tutorial de configuración inicial para servidores.

      Paso 1: Configurar Python

      Para iniciar el proceso, instalaremos las dependencias que necesitamos para nuestro entorno de programación de Python desde los repositorios de Ubuntu. Ubuntu 20.04 viene preinstalado con Python 3. Usaremos el pip del administrador de paquetes de Python para instalar componentes adicionales un poco más tarde.

      Necesitaremos primero actualizar el índice de paquetes local apt y luego descargaremos e instalaremos los paquetes:

      A continuación, instale pip y los archivos de encabezado de Python, utilizados por algunas dependencias de Jupyter:

      • sudo apt install python3-pip python3-dev

      Ahora podemos proceder a configurar un entorno virtual de Python en el que instalaremos Jupyter.

      Paso 2: Crear un entorno virtual de Python para Jupyter

      Ahora Python 3, sus archivos de encabezado y pip están listos para comenzar, podemos crear un entorno virtual de Python para administrar nuestros proyectos. Instalaremos Jupyter en este entorno virtual.

      Para ello, primero necesitaremos acceso al comando virtualenv, que podemos instalar con pip.

      Actualice pip e instale el paquete escribiendo lo siguiente:

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

      El indicador -H garantiza que la política de seguridad defina la variable de entorno home como el directorio de inicio del usuario de destino.

      Con virtualenv ya instalado, podemos comenzar a crear nuestro entorno. Cree un directorio en el que podamos guardar los archivos de nuestro proyecto y posiciónese en él: Daremos a este directorio el nombre my_project_dir, pero deberá usar un nombre que sea significativo para usted y para el trabajo que está desarrolle.

      • mkdir ~/my_project_dir
      • cd ~/my_project_dir

      En el directorio del proyecto, crearemos un entorno virtual de Python. A los efectos de este tutorial, le daremos el nombre my_project_env, pero debería asignarle uno que se relacione con su proyecto.

      • virtualenv my_project_env

      Con esto, se creará un directorio llamado my_project_env dentro de su directorio my_project_dir. Dentro de este, se instalarán una versión local de Python y una versión local de pip. Podemos usar esto para instalar y configurar un entorno aislado de Python para Jupyter.

      Antes de instalar Jupyter, debemos activar el entorno virtual. Puede hacerlo escribiendo lo siguiente:

      • source my_project_env/bin/activate

      Su línea de comandos cambiará para indicar que ahora realizará operaciones en un entorno virtual de Python. Su línea de comandos ahora leerá algo como esto: (my_project_env)user@host:~/my_project_dir$.

      En este momento, está listo para instalar Jupyter en este entorno virtual.

      Paso 3: Instalar Jupyter

      Una vez activado su entorno virtual, instale Jupyter con la instancia local de pip.

      Nota: Cuando se active el entorno virtual (cuando (my_project_env) se encuentre al inicio de su línea de comandos), use pip en lugar de pip3, incluso si emplea Python 3. La copia del entorno virtual de la herramienta siempre se llama pip, independientemente de la versión de Python.

      En este punto, habrá instalado con éxito todo el software necesario para ejecutar Jupyter. Ahora podremos iniciar el servidor de Notebook.

      Paso 4: Ejecutar Jupyter Notebook

      Ya dispone de todo lo que necesita para ejecutar Jupyter Notebook. Para ejecutarlo, introduzca el siguiente comando:

      Se mostrará un registro de las actividades de Jupyter Notebook en el terminal. Cuando se ejecuta Jupyter Notebook, este funciona en un número de puerto específico. Normalmente, el primer notebook que ejecute usará el puerto 8888. Para verificar el número de puerto específico en el que se ejecuta Jupyter Notebook, consulte el resultado del comando utilizado para iniciarlo:

      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/my_project_dir [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

      Si ejecuta Jupyter Notebook en una computadora local (no en un servidor), puede dirigirse a la URL que se muestra para conectarse a Jupyter Notebook. Si ejecuta Jupyter Notebook en un servidor, deberá establecer conexión con este usando túneles SSH como se indica en la siguiente sección.

      En este punto, podrá mantener la conexión SSH abierta y Jupyter Notebook en ejecución, o bien cerrar la aplicación y volver a ejecutarla una vez que configure los túneles SSH. Optaremos por detener el proceso de Jupyter Notebook. Lo ejecutaremos de nuevo una vez que configuremos los túneles SSH. Para detener el proceso de Jupyter Notebook, presione CTRL+C, escriba Y y luego presione ENTER para confirmar. Se mostrará el siguiente resultado:

      Output

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

      A continuación, configuraremos un túnel SSH para poder acceder al Notebook.

      Paso 5: Establecer conexión con el servidor usando túneles SSH

      En esta sección, mostraremos cómo establecer una conexión con la interfaz web de Jupyter Notebook usando túneles SSH. Debido a que Jupyter Notebook se ejecutará en un puerto específico en el servidor (como el :8888 y el :8889, entre otros), los túneles SSH le permiten establecer conexión con el puerto del servidor de forma segura.

      En los dos apartados siguientes, se describe la forma de crear un túnel SSH desde 1) un Mac o Linux y 2) Windows. Consulte el apartado que corresponda a su computadora local.

      Túeneles SSH con una Mac o Linux

      Si está usando un equipo local Mac o Linux, los pasos para crear el túnel SSH son similares a usar SSH para iniciar sesión en su servidor remoto, excepto que hay parámetros adicionales en el comando ssh. En este apartado, se describirán los parámetros adicionales necesarios en el comando ssh para implementar un túnel con éxito.

      Esta implementación es posible ejecutando el siguiente comando SSH en una nueva ventana del terminal local:

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

      El comando ssh abre una conexión SSH, pero -L especifica que se debe reenviar el puerto determinado en el host local (cliente) al host y puerto determinados en el lado remoto (servidor). Esto significa que todo lo que está en ejecución en el segundo número de puerto (por ejemplo 8888) en el servidor aparecerá en el primer número de puerto (por ejemplo 8888) en su computadora local.

      Cambie de forma opcional el puerto 8888 por uno que elija para evitar usar un puerto ya utilizado por otro proceso.

      server_username es su nombre de usuario (por ejemplo sammy) en el servidor que creó y your_server_ip es la dirección IP de su servidor.

      Por ejemplo, para el nombre de usuario sammy y la dirección del servidor 203.0.113.0, el comando sería el siguiente:

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

      Si no se produce ningún error después de ejecutar el comando ssh -L, podrá desplazarse a su entorno de programación y ejecutar Jupyter Notebook:

      Verá un resultado con una URL. Desde un navegador web en su máquina local, abra la interfaz web de Jupyter Notebook con la URL que comienza con http://localhost:8888. Asegúrese de que el número de token esté incluido o ingrese la cadena de número de token cuando se solicite en http://localhost:8888.

      Túneles SSH con Windows y Putty

      Si usa Windows, puede crear un túnel SSH usando Putty.

      Primero, ingrese la dirección URL o IP del servidor como el nombre de host, como se muestra:

      Establecer el nombre de host para el túnel SSH

      A continuación, haga clic en SSH en la parte inferior del panel izquierdo, para expandir el menú, y luego en Tunnels. Introduzca el número del puerto local que quiera usar para acceder a Jupyter en su máquina local. Seleccione 8000, o un número mayor, para evitar los puertos utilizados por otros servicios y fije el destino en localhost:8888, donde :8888 sea el número del puerto en el que se ejecute Jupyter Notebook.

      Luego, haga clic en el botón Add. Deberían aparecer los puertos en la lista de Forwarded ports:

      Lista de Forwarded ports

      Por último, haga clic en el botón Open para establecer conexión con el servidor a través de SSH y crear un túnel entre los puertos deseados. Diríjase a http://localhost:8000 (o cualquier puerto que haya elegido) en un navegador web para conectarse al Jupyter Notebook que funciona en el servidor. Asegúrese de que el número de token esté incluido, o ingrese la cadena de número de token cuando se solicite en http://localhost:8000.

      Paso 6: Usar Jupyter Notebook

      Esta sección repasa el uso básico de Jupyter Notebook. Si Jupyter Notebook aún no está en ejecución, inícielo con el comando jupyter notebook.

      Con esto, debería establecer conexión con este usando un navegador web. Jupyter Notebook es una herramienta muy poderosa que dispone de muchas características. En esta sección se mostrarán algunas de las características básicas para que comience a usar Notebook. Jupyter Notebook mostrará todos los archivos y las carpetas en el directorio desde el que se ejecuta. Por ello, cuando trabaje en un proyecto asegúrese de iniciarlo desde el directorio del proyecto.

      Para crear un nuevo archivo de Notebook, seleccione New > Python 3 en el menú desplegable que se encuentra en la parte superior derecha:

      Crear un nuevo notebook de Python 3

      Con esto se abrirá un Notebook. Ahora podemos ejecutar el código de Python en la celda o cambiar la celda a lenguaje de marcado. Por ejemplo, cambie la primera celda para aceptar el lenguaje de marcado haciendo clic en Cell > Cell Type > Markdown en la barra de navegación de la parte superior. Con esto, podremos escribir notas usando el lenguaje de marcado e incluso incluir ecuaciones escritas en LaTeX disponiéndolas entre los símbolos de $$. Por ejemplo, escriba lo siguiente en la celda después del cambio a lenguaje de marcado:

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

      Para convertir el marcado en texto con formato, pulse las teclas CTRL y ENTER. Debería obtener un resultado similar al siguiente:

      Resultados de lenguaje de marcado

      Puede utilizar las celdas de lenguaje de marcado para crear notas y documentar su código. Implementaremos esa ecuación e imprimiremos el resultado. Haga clic en la celda superior, luego pulse las teclas ALT y ENTER juntas para añadir una celda debajo. Introduzca el siguiente código en la nueva celda.

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

      Para ejecutar el código, presione CTRL+ENTER. Obtendrá los siguientes resultados:

      Resultado de la primera ecuación

      Ahora podrá importar módulos y usar el Notebook como lo haría con cualquier otro entorno de desarrollo de Python.

      Conclusión

      ¡Felicitaciones! Ahora debería poder escribir código y notas de Python que puedan reproducirse en lenguaje de marcado usando Jupyter Notebook. Si desea acceder a una visita rápida de Jupyter Notebook desde la interfaz, seleccione Help > User Interface Tour en el menú de navegación superior para obtener más información.

      A partir de aquí, puede iniciar un proyecto de análisis y visualización de datos leyendo Análisis y visualización de datos con pandas y Jupyter Notebook en Python 3.



      Source link

      Como configurar o Jupyter Notebook com o Python 3 no Ubuntu 20.04 e se conectar via protocolo de tunelamento SSH


      Introdução

      O Jupyter Notebook é um aplicativo Web de código aberto que permite que você crie e compartilhe códigos interativos, visualizações, e mais. Essa ferramenta pode ser usada com várias linguagens de programação, incluindo o Python, Julia, R, Haskell, e Ruby. Muitas vezes, ele é usado para trabalhar com dados, modelagem estatística e machine learning.

      Jupyter Notebooks (ou apenas “Notebooks”) são documentos produzidos pelo app Jupyter Notebook, que contêm tanto códigos de computador quanto elementos de rich text (parágrafos, equações, figuras, links, etc.) que ajudam na apresentação e compartilhamento de pesquisa reprodutível. Sendo assim, eles podem ser uma ferramenta excelente para se usar em apresentações baseadas em dados ou programação, ou como uma ferramenta de ensino.

      Este tutorial irá guiá-lo na configuração do Jupyter Notebook para ser executado a partir de um servidor Ubuntu 20.04, bem como demonstrar como se conectar e usar o notebook de uma máquina local via tunelamento. Ao final deste guia, você será capaz de executar código em 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 20.04 com um firewall básico e um usuário não root com privilégios sudo configurados. Você pode aprender como configurar isso examinando nosso guia de configuração inicial de servidor.

      Passo 1 — Configurando o Python

      Para começar o processo, instalaremos as dependências que precisamos para o nosso ambiente de programação Python dos repositórios Ubuntu. O Ubuntu 20.04 vem pré-instalado com o Python 3. Usaremos o gerenciador de pacotes do Python para instalar componentes adicionais um pouco mais tarde.

      Primeiro, precisamos atualizar o índice de pacotes local apt e, em seguida, baixar e instalar os pacotes:

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

      • sudo apt install python3-pip python3-dev

      Agora, podemos continuar para a configuração de um ambiente virtual Python onde instalaremos o Jupyter.

      Passo 2 — Criar um ambiente virtual Python para o Jupyter

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

      Para fazer isso, primeiro precisamos de acesso ao comando virtualenv, que podemos instalar com o pip.

      Atualize pip e instale o pacote digitando:

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

      O sinalizador -H garante que a política de segurança aloca a variável de ambiente home no diretório home do usuário de destino.

      Com o virtualenv instalado, podemos começar a formar nosso ambiente. Crie um diretório onde possamos manter nossos arquivos do projeto e vá até ele: Vamos chamá-lo de my_project_dir, mas você deve usar um nome que tenha significado para você e para aquilo no que está trabalhando.

      • mkdir ~/my_project_dir
      • cd ~/my_project_dir

      Dentro do diretório do projeto, vamos criar um ambiente virtual Python. Para os fins deste tutorial, vamos chamá-lo de my_project_env, mas você deve chamá-lo de algo que seja relevante para o seu projeto.

      • virtualenv my_project_env

      Isso criará um diretório chamado my_project_env dentro do seu diretório my_project_dir. Lá 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 my_project_env/bin/activate

      Seu prompt deverá mudar para indicar que você agora está operando em um ambiente virtual Python. Agora, você verá em seu prompt de comando algo parecido com isto: (my_project_env)user@host:~/my_project_dir$.

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

      Passo 3 — Instalar o Jupyter

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

      Nota: quando o ambiente virtual for ativado (quando seu prompt tiver (my_project_env) antecedendo-o) use o pip em vez do pip3, mesmo se estiver usando o Python 3. A cópia da ferramenta do ambiente virtual é sempre chamada de pip, independentemente da versão do Python.

      Até aqui, você instalou todos os softwares necessários para executar o Jupyter. Agora, podemos iniciar o servidor Notebook.

      Passo 4 — Executando o Jupyter Notebook

      Agora, você tem tudo o que precisa para executar o Jupyter Notebook! Para executá-lo, utilize 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ê executar geralmente usará a porta 8888. Para verificar em qual número de porta específico o Jupyter Notebook está em execução, consulte o resultado 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/my_project_dir [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 estiver executando o Jupyter Notebook em um computador local (não em um servidor), você pode acessar o URL exibido para se conectar ao Jupyter Notebook. Se estiver executando o Jupyter Notebook em um servidor, você precisará se conectar ao servidor usando o protocolo de tunelamento SSH, como descrito na próxima seção.

      Neste ponto, você pode manter a conexão via protocolo SSH aberta e manter o Jupyter Notebook em execução, ou pode sair do app e executá-lo novamente assim que configurar o protocolo de tunelamento SSH. Vamos optar por parar o processo do Jupyter Notebook. Vamos executá-lo novamente assim que tivermos o protocolo de tunelamento SSH configurado. Para parar o processo do Jupyter Notebook, pressione CTRL+C, digite Y, e, em seguida, ENTER para confirmar. O seguinte resultado será exibido:

      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 — Conectando-se ao servidor usando o protocolo de tunelamento SSH

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

      As duas subseções a seguir descrevem como criar um túnel SSH a partir de 1) um Mac ou Linux, ou 2) Windows. Por favor, consulte a subsecção referente ao seu computador local.

      Protocolo de tunelamento SSH com um Mac ou Linux

      Se estiver usando um computador local do Mac ou Linux, os passos para a criação de um túnel SSH são semelhantes a usar o SSH para fazer login em seu servidor remoto. Apenas haverão alguns parâmetros adicionais no comando ssh. Esta subsecção irá mostrar os parâmetros adicionais necessários no comando ssh para estabelecer o tunelamento 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 your_server_username@your_server_ip

      O comando ssh abre uma conexão via protocolo SSH, mas -L especifica que a porta em questão no host (cliente) local será enviada ao host e porta em questão no lado remoto (server). Isso significa que tudo que esteja em execução no segundo número de porta (por exemplo, 8888) no servidor aparecerá no primeiro número de porta (por exemplo, 8888) em seu computador local.

      Se precisar, altere a porta 88 para outra de sua escolha para evita usar uma porta que já esteja em uso por outro processo.

      server_username é seu nome de usuário (por exemplo, sammy) no servidor que você criou e your_server_ip é o endereço IP do seu servidor.

      Por exemplo, para o nome de usuário sammy e para 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 após executar o comando ssh -L, vá para seu ambiente de programação e execute o Jupyter Notebook:

      Você receberá um resultado com um URL. A partir de um navegador Web em sua máquina local, abra a interface Web do Jupyter Notebook com o URL que começa com http://localhost:8888. Certifique-se de que o número do token esteja incluído, ou digite a string do número de token quando solicitado em http://localhost:8888.

      Protocolo de tunelamento SSH com Windows e Putty

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

      Primeiro, digite o URL do servidor ou endereço IP como nome de host, assim como mostrado:

      Definir nome de host para o túnel SSH

      Em seguida, clique em SSH no final do painel esquerdo para expandir o menu e, depois disso, 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 maior para evitar portas usadas por outros serviços, e defina o destino como localhost:8888 onde o :8888 é o número da porta em que o Jupyter Notebook está em execução.

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

      Lista de portas encaminhadas

      Por fim, clique no botão Open para se conectar ao servidor via SSH e aplicar o tunelamento nas portas desejadas. Vá para http://localhost:8000 (ou qualquer porta que você tenha escolhido) em um navegador Web para se conectar ao Jupyter Notebook em execução no servidor. Certifique-se de que o número do token esteja incluído, ou digite a string do número de token quando solicitado em http://localhost:8000.

      Passo 6 — Usando o Jupyter Notebook

      Esta seção aborda o básico do uso do Jupyter Notebook. Se você ainda não tiver 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 irá mostrar alguns recursos básicos para que você comece a utilizar o Notebook. O Jupyter Notebook irá mostrar todos os arquivos e pastas do diretório em que ele é executado. Dessa forma, quando 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 à direita:

      Criar um novo notebook Python 3

      Isso 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 o Markdown clicando em Cell > Cell Type > Markdown na barra de navegação superior. Agora, podemos escrever notas usando o Markdown e até incluir equações escritas em LaTeX, colocando-as entre os símbolos $$. Por exemplo, digite o seguinte na célula após alterá-la para markdown:

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

      Para transformar o markdown em rich text, pressione as teclas CTRL e ENTER. Você deve receber um resultado similar ao seguinte:

      Resultados do markdown

      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, em seguida, pressione as teclas ALT e ENTER juntas 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 seguinte resultados:

      Resultados da primeira equação

      Agora, você é capaz de importar módulos e usar o Notebook como faria com qualquer outro ambiente de desenvolvimento do Python.

      Conclusão

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

      A partir daqui, você pode iniciar um projeto de análise de dados e visualização lendo Análise de dados e a visualização com o pandas e o Jupyter Notebook em Python 3.



      Source link