One place for hosting & domains

      Executar

      Como usar o nsh para executar comandos remotos seguros no Ubuntu 18.04


      Introdução

      Muitas vezes é difícil gerenciar várias máquinas em um banco de dados diariamente. Ainda que o Secure Shell (SSH) seja uma boa escolha para o acesso remoto, o protocolo em si possui alguns inconvenientes tanto em conveniência como em segurança.

      Por exemplo, máquinas remotas precisam ter um endereço IP público e uma porta redirecionada para acessá-los, o que os expõe à Internet, ou pelo menos a uma rede maior. Isso é especialmente preocupante caso use uma senha para autenticação em vez de um par de chaves público e privado. Além disso, caso não conheça a chave pública da máquina remota antecipadamente, você fica vulnerável a um ataque “man-in-the-middle”. E muitas máquinas remotas que você vai querer acessar não têm endereço IP público ou têm um endereço IP dinâmico que você não sabe.

      Além disso, o SSH exige uma conexão por sessão remota. Se um usuário precisa executar um único comando em centenas ou mesmo milhares de máquinas, é preciso primeiro estabelecer uma conexão com cada máquina com um handshake TCP, que é menos eficiente.

      O NKN Shell, ou nsh, é uma alternativa ao SSH que fornece uma maneira conveniente e segura de executar comandos remotos. O nsh aproveita a rede pública global do NKN, que fornece transmissão de dados segura e descentralizada. A arquitetura usa endereços únicos que contêm uma chave pública usada tanto para o roteamento quanto para a criptografia end-to-end sem nenhuma infraestrutura de chave pública (PKI). A rede também não exige que o servidor remoto tenha um endereço IP público. O servidor remoto precisa ter acesso à Internet e ser capaz de estabelecer conexões HTTP de saída e de websocket. Como resultado, suas máquinas remotas não são expostas à Internet aberta.

      Neste tutorial, você usará o daemon do NKN shell e o aplicativo Xterm do cliente NKN Shell para executar comandos em uma máquina remota. Para fazer isso, você instalará e configurará o daemon do NKN Shell em uma máquina remota com acesso à internet, gerará um par de chaves e fará sua conexão de um cliente.

      Pré-requisitos

      Para seguir este tutorial, você precisará do seguinte:

      Passo 1 — Instalando o NKN Shell em um servidor remoto

      Primeiro, instale o daemon do NKN shell (nsd) no seu servidor. Esse aplicativo invoca o nkn-multiclient, que se conectará à rede pública do NKN e receberá um endereço para o roteamento. Então, o daemon escutará comandos shell de entrada de clientes autenticados e listados, executará esses comandos e, em seguida, enviará os resultados de volta.

      Comece baixando os binários nshd pré-compilados do GitHub mais recentes:

      • wget https://github.com/nknorg/nkn-shell-daemon/releases/latest/download/linux-amd64.tar.gz

      Descompacte o arquivo:

      • tar -zxvf linux-amd64.tar.gz

      Então, mova os arquivos para o diretório /usr/local/bin, para que eles estejam disponíveis em todo o sistema:

      • sudo mv ./linux-amd64/* /usr/local/bin/

      Em seguida, você configurará isso para ser executado como um processo daemon usando o Systemd, para que ele seja reiniciado caso o servidor seja redefinido.

      Crie um arquivo chamado nshd.service em /etc/systemd/system:

      • sudo nano /etc/systemd/system/nshd.service

      Adicione a seguinte definição de serviço ao arquivo para configurar o serviço:

      /etc/systemd/system/nshd.service

      [Unit]
      Description=NKN Shell Daemon
      After=network.target
      
      [Service]
      Type=simple
      User=root
      Group=root
      Restart=always
      ExecStart=/usr/local/bin/nshd
      
      [Install]
      WantedBy=multi-user.target
      

      Saiba mais sobre arquivos de unidade do Systemd em Entendendo unidades do Systemd e arquivos de unidade.

      Salve o arquivo e saia do editor. Então, habilite e inicie o serviço nshd com os seguintes comandos:

      • sudo systemctl enable nshd.service
      • sudo systemctl start nshd.service

      Execute o seguinte comando para garantir que o serviço esteja ativo e iniciado:

      • sudo systemctl status nshd.service

      Você verá que o status está ativo:

      Output

      ● nshd.service - NKN Shell Daemon Loaded: loaded (/etc/systemd/system/nshd.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2020-02-19 19:16:02 UTC; 7s ago Main PID: 3457 (nshd) Tasks: 10 (limit: 1152) CGroup: /system.slice/nshd.service └─3457 /usr/local/bin/nshd Feb 19 19:16:02 your_hostname systemd[1]: Started NKN Shell Daemon. Feb 19 19:16:03 your_hostname nshd[3457]: Create directory /etc/nshd/ Feb 19 19:16:03 your_hostname nshd[3457]: Create password and save to file /etc/nshd/wallet.pswd Feb 19 19:16:03 your_hostname nshd[3457]: Create wallet and save to file /etc/nshd/wallet.json Feb 19 19:16:03 your_hostname nshd[3457]: Create authorized pubkeys file /etc/nshd/authorized_pubkeys Feb 19 19:16:03 your_hostname nshd[3457]: Listening at d46567b883a3070ee3fe879d9fa2d5dc55a95f79ff2797c42df36c6979e5c4Aba

      Para se conectar ao seu servidor, você precisará obter seu endereço NKN, que pode ser encontrado no resultado do comando anterior. Também é possível executar o seguinte comando para obter o endereço:

      Você verá seu endereço aparecer:

      Output

      e70ca28ede84fc0659f2869255e8a393aef35b4fa5a7e036f29127c7dba75383

      Anote este endereço, uma vez que precisará dele para se conectar ao seu servidor.

      Agora que o daemon está em execução e escutando, é possível configurar o cliente baseado na Web para falar com o servidor.

      Passo 2 — Configurando as permissões para o cliente NKN Shell

      Você precisará de um cliente compatível que possa se conectar à máquina remota. Neste tutorial, você usará o cliente Xterm do NKN Shell, um cliente NKN shell baseado na Web. Há várias maneiras diferentes de executá-lo:

      Neste tutorial, você usará a versão hospedada. Na sua máquina local, abra o navegador Web e navegue até https://nsh.nkn.org. Você verá uma tela de boas vindas:

      O cliente do Shell

      Clique em Generate New Key Pair (Gerar novo par de chaves). Suas chaves serão geradas e exibidas como mostrado na imagem seguinte:

      O par de chaves gerado

      Nota: quando gerar um novo par de chaves, você verá um seed secreto. Mantenha esse seed secreto seguro, assim como você faria com sua chave privada SSH. Qualquer um que tenha esse seed secreto pode usá-lo para regenerar sua chave pública e, em seguida, executar comandos em suas máquinas remotas. Seu navegador se lembrará desse seed, mas você deve copiá-lo em um lugar seguro para que possa usá-lo novamente em uma nova máquina.

      Salve o seed secreto em um lugar seguro. É possível usá-lo mais tarde para regenerar sua chave pública para que você possa se conectar a partir de uma máquina de cliente diferente.

      Como trata-se de um novo par de chaves, é preciso adicionar a chave pública ao arquivo /etc/nshd/authorized_pubkeys no seu servidor.

      O /etc/nshd/authorized_pubkeys tem um papel semelhante ao arquivo ~/authorized_keys, que controla quais chaves públicas SSH podem fazer login. O arquivo authorized_pubkeys especifica qual usuário está associado a uma chave. Para fins de segurança, faça login usando um usuário não raiz neste tutorial, de modo que a chave pública gerada seja associada com seu usuário sammy criado no tutorial pré-requisito deste artigo, Configuração inicial de servidor.

      Para associar um usuário à chave pública, será necessário obter o ID de usuário (UID) e o ID de grupo (GID) deste usuário. Execute o seguinte comando no seu servidor, enquanto logado como o usuário sammy:

      Você verá o UID e o GID do usuário:

      Output

      uid=1000(sammy) gid=1000(sammy) groups=1000(sammy),27(sudo)

      Agora, abra o arquivo authorized_pubkeys no seu editor:

      • sudo nano /etc/nshd/authorized_pubkeys

      Adicione uma linha única que contenha a chave pública, UID e GID, separados por espaços:

      authorized_pubkeys

      5d5367a5730427c205904a4457392051d2045dbce0186518fb6eb24dd9e41ba6 1000 1000
      

      Salve o arquivo.

      Verifique se o arquivo contém o conteúdo correto:

      • cat /etc/nshd/authorized_pubkeys

      Você verá sua chave impressa na tela:

      Output

      5d5367a5730427c205904a4457392051d2045dbce0186518fb6eb24dd9e41ba6 1000 1000

      Então, reinicie o daemon nshd para aplicar as alterações:

      • sudo systemctl restart nshd.service

      Agora, vamos testá-lo. Para isso, conecte-se ao servidor e execute um comando.

      Passo 3 — Enviando um comando para a máquina remota e recebendo uma resposta

      No cliente NKN Shell, digite seu endereço remoto nshd do Passo 1, bem como um identificador de cliente opcional:

      O site nsh com o endereço remoto preenchido

      Clique em Connect (Conectar) para iniciar a conexão.

      Você se conectará à sua máquina remota e será exibido um prompt de terminal dentro do navegador. A partir daqui, use-o da mesma forma que o SSH. Por exemplo, execute o comando a seguir para alternar para o diretório /etc/nshd:

      Então, liste o conteúdo do diretório:

      Você verá o conteúdo dele:

      Output

      authorized_pubkeys wallet.json wallet.pswd

      Desconecte-se digitando exit. Quando precisar se reconectar, visite novamente a interface Web e digite seus detalhes de conexão. Caso gere um novo par de chaves, será necessário adicionar a nova chave pública ao seu servidor.

      Conclusão

      Neste tutorial, você instalou e configurou o nsh para enviar comandos de maneira segura e conveniente para uma máquina remota. O nsh é uma ótima maneira de acessar suas máquinas remotas quando você precisa executar rapidamente um comando para obter o status mais recente de um serviço ou espiar algumas definições de configuração. O aplicativo se baseia na rede pública global da NKN e é gratuito para usar. Dessa forma, você pode incorporá-lo no seu próprio aplicativo ou fluxo de trabalho hoje.

      Também é possível explorar o nkn-tunnel, que é compatível com o SSH ou qualquer outro aplicativo baseado no TCP.



      Source link

      Como Executar Transações no Redis


      Introdução

      O Redis é um datastore ou armazenamento de dados open-source de chave-valor na memória. O Redis lhe permite planejar uma sequência de comandos e executá-los um após o outro, um procedimento conhecido como transação. Cada transação é tratada como uma operação ininterrupta e isolada, o que garante a integridade dos dados. Os clientes não podem executar comandos enquanto um bloco de transação está sendo executado.

      Este tutorial aborda como executar e cancelar transações e também inclui algumas informações sobre as armadilhas comumente associadas às transações.

      Como Utilizar Este Guia

      Este guia está no formato de referência rápida com trechos de linha de comando independentes. Recomendamos que você pule para qualquer seção que seja relevante para a tarefa que você está tentando concluir.

      Os comandos mostrados neste guia foram testados em um servidor Ubuntu 18.04 executando a versão 4.0.9 do Redis. Para configurar um ambiente semelhante, você pode seguir o Passo 1 do nosso guia Como Instalar e Proteger o Redis no Ubuntu 18.04. Vamos demonstrar como esses comandos se comportam executando-os com redis-cli, a interface de linha de comando do Redis. Observe que se você estiver usando uma interface Redis diferente — Redli, por exemplo — a saída exata de certos comandos pode ser diferente.

      Como alternativa, você pode provisionar uma instância de banco de dados Redis gerenciada para testar esses comandos, mas observe que, dependendo do nível de controle permitido pelo seu provedor de banco de dados, alguns comandos neste guia podem não funcionar como descrito. Para provisionar um banco de dados gerenciado na DigitalOcean, siga nossa documentação de produto para Managed Databases. Então, você deve instalar ou o Redli ou configurar um túnel TLS para conectar-se ao banco de dados gerenciado por TLS.

      Executando Transações

      O comando multi diz ao Redis para iniciar um bloco de transação. Quaisquer comandos subsequentes serão colocados na fila até você executar um comando exec, que os executará.

      Os seguintes comandos formam um único bloco de transação. O primeiro comando inicia a transação, o segundo define uma chave contendo uma string com o valor de 1, o terceiro incrementa o valor em 1, o quarto incrementa seu valor em 40, o quinto retorna o valor atual da string e o último executa o bloco de transação:

      • multi
      • set key_MeaningOfLife 1
      • incr key_MeaningOfLife
      • incrby key_MeaningOfLife 40
      • get key_MeaningOfLife
      • exec

      Depois de executar o multi, o redis-cli responderá a cada um dos seguintes comandos com QUEUED. Depois de executar o comando exec, ele mostrará a saída de cada um desses comandos individualmente:

      Output

      1) OK 2) (integer) 2 3) (integer) 42 4) "42"

      Os comandos incluídos em um bloco de transação são executados sequencialmente na ordem em que estão enfileirados. As transações Redis são atômicas, o que significa que todos os comandos em um bloco de transações são processados (ou seja, são aceitos como válidos e enfileirados para serem executados) ou nenhum deles. No entanto, mesmo que um comando seja enfileirado com êxito, ele ainda poderá gerar um erro quando executado. Nesses casos, os outros comandos da transação ainda podem ser executados, mas o Redis ignorará o comando causador de erros. Consulte a seção compreendendo erros de transação para mais detalhes.

      Cancelando Transações

      Para cancelar uma transação, execute o comando discard. Isso impede que qualquer comando previamente enfileirado seja executado:

      • multi
      • set key_A 146
      • incrby key_A 10
      • discard

      Output

      OK

      O comando discard retorna a conexão ao estado normal, o que instrui o Redis a executar comandos únicos, como de costume. Você precisará executar o multi novamente para informar ao servidor que está iniciando outra transação.

      Entendendo Erros de Transação

      Alguns comandos podem ser impossíveis de enfileirar, como comandos com erros de sintaxe. Se você tentar enfileirar um comando sintaticamente incorreto, o Redis retornará um erro.

      A transação a seguir cria uma chave chamada key_A e depois tenta incrementá-la em 10. No entanto, um erro de ortografia no comando incrby gera um erro e fecha a transação:

      • multi
      • set key_A 146
      • incrbuy key_A 10

      Output

      (error) ERR unknown command 'incrbuy'

      Se você tentar executar um comando exec depois de tentar enfileirar um comando com um erro de sintaxe como esse, você receberá outra mensagem de erro informando que a transação foi descartada:

      Output

      (error) EXECABORT Transaction discarded because of previous errors.

      Em casos como este, você precisará reiniciar o bloco de transações e certificar-se de inserir cada comando corretamente.

      Alguns comandos impossíveis são possíveis de se enfileirar, como executar incr em uma chave que contém apenas uma string. Como esse comando é sintaticamente correto, o Redis não retornará um erro se você tentar incluí-lo em uma transação e não impedirá que você execute o exec. Em casos como este, todos os outros comandos na fila serão executados, mas o comando impossível retornará um erro:

      • multi
      • set key_A 146
      • incrby key_A "ten"
      • exec

      Output

      1) OK 2) (error) ERR value is not an integer or out of range

      Para mais informações sobre como o Redis lida com erros dentro de transações, consulte a documentação oficial sobre o assunto.

      Conclusão

      Este guia detalha vários comandos usados para criar, executar e cancelar transações no Redis. Se houver outros comandos, argumentos ou procedimentos relacionados que você gostaria de ver descritos neste guia, peça ou faça sugestões nos comentários abaixo.

      Para obter mais informações sobre comandos Redis, consulte nossa série de tutoriais Como Gerenciar um Banco de Dados Redis.



      Source link

      Como Instalar, Executar, e Conectar no Jupyter Notebook em um Servidor Remoto


      O autor selecionou a Fundação do Software Apache para receber uma doação de $100 como parte do programa Write for DOnations.

      Introdução

      O Jupyter Notebook é um aplicativo interativo Web de código aberto que permite que você escreva e execute códigos de computador em mais de 40 linguagens de programação, incluindo Python, R, Julia, e Scala. Um produto do Projeto Jupyter, Jupyter Notebook é útil para a programação iterativa, uma vez que ele permite que você escreva um pequeno fragmento de código, execute-o, e retorne o resultado.

      O Jupyter Notebook dá a capacidade de criar documentos de anotação, referidos simplesmente como “notebooks”. Notebooks criados a partir do Jupyter Notebook são documentos de pesquisa compartilháveis, reproduzíveis que incluem elementos de rich text, equações, código e seus resultados (figuras, tabelas, gráficos interativos). Os notebooks também podem ser exportados para arquivos de código bruto, documentos HTML ou PDF, ou usados para criar slides interativos ou páginas Web.

      Este artigo irá guiar você em como instalar e configurar o aplicativo Jupyter Notebook em um servidor Web do Ubuntu 18.04 e como se conectar a ele do seu computador local. Além disso, também vamos ver como usar o Jupyter Notebook para executar um exemplo de código Python.

      Pré-requisitos

      Para completar este tutorial, você precisará de:

      Além disso, se seu computador local estiver usando o Windows, você precisará instalar o PuTTY nele para estabelecer um túnel SSH para seu servidor. Siga nosso guia em Como Criar Chaves SSH com o PuTTY no Windows para baixar e instalar o PuTTY.

      Passo 1 — Instalando o Jupyter Notebook

      Uma vez que os notebook são usados para escrever, executar e ver o resultado de pequenos fragmentos de código, você primeiro precisará configurar o suporte de linguagem de programação. O Jupyter Notebook usa um kernel específico de linguagem, um programa de computador que executa e examina códigos. O Jupyter Notebook tem muitos kernels em diferentes linguagens, sendo padrão o IPython. Neste tutorial, você irá configurar o Jupyter Notebook para executar códigos Python através do kernel do IPython.

      Supondo que você tenha seguido os tutoriais ligados na seção Pré-requisitos, você deve ter o Python 3, pip e um ambiente virtual instalados. Os exemplos neste guia seguem a convenção usada no tutorial pré-requisito na instalação do Python 3, que designa o ambiente virtual “my_env”, mas você deve sentir-se à vontade para renomear isso.

      Inicie ativando o ambiente virtual:

      • source my_env/bin/activate

      Em seguida, seu prompt será prefixado com o nome do seu ambiente.

      Agora que você está no seu ambiente virtual, vá em frente e instale o Jupyter Notebook:

      • python3 -m pip install jupyter

      Se a instalação tiver sido bem sucedida, você verá um resultado similar ao seguinte:

      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

      Com isso, o Jupyter Notebook foi instalado no seu servidor. Em seguida, vamos ver como executar o aplicativo.

      Passo 2 — Executando o Jupyter Notebook

      O Jupyter Notebook deve ser executado do seu VPS para que você possa se conectar a ele da sua máquina local utilizando um Túnel SSH e seu navegador Web favorito.

      Para executar o servidor do Jupyter Notebook, digite o seguinte comando:

      Após executar este comando, você verá um resultado similar ao seguinte:

      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

      Você pode notar no resultado que há um aviso No web browser found. Isso é esperado, uma vez que o aplicativo está funcionando em um servidor e você provavelmente ainda não instalou um navegador Web nele. Este guia irá examinar como se conectar ao Notebook no servidor utilizando o tunelamento SSH na seção seguinte.

      Por enquanto, saia do Jupyter Notebook pressionando CTRL+C seguido por y, e então pressione 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

      Então, saia do servidor utilizando o comando exit:

      Você acabou de executar o Jupyter Notebook no seu servidor. Entretanto, para acessar o aplicativo e começar a trabalhar com notebooks, você precisará se conectar ao aplicativo utilizando o tunelamento SSH e um navegador Web no seu computador local.

      O Tunelamento SSH é uma maneira simples e rápida de se conectar ao aplicativo Jupyter Notebook em execução no seu servidor. Secure shell (mais frequentemente conhecido como SSH) é um protocolo de rede que permite que você se conecte a um servidor remoto com segurança em uma rede não segura.

      O protocolo SSH inclui um mecanismo de encaminhamento de porta que permite que você encaminhe certos aplicativos em execução em um número de porta específico em um servidor para um número de porta específico no seu computador local. Iremos aprender como “encaminhar” com segurança o aplicativo Jupyter Notebook em execução no seu servidor (na porta 8888, por padrão) para uma porta no seu computador local.

      O método que você usa para estabelecer um túnel SSH irá depender do sistema operacional do seu computador local. Pule para a subsecção abaixo que é a mais relevante para a sua máquina.

      Nota: É possível configurar e instalar o Jupyter Notebook utilizando o Console Web do DigitalOcean, mas se conectar ao aplicativo através de um túnel SSH deve ser feito através do terminal ou com o PuTTY.

      Tunelamento SSH utilizando macOS ou Linux

      Se seu computador local está executando Linux ou macOS, é possível estabelecer um túnel SSH apenas executando um único comando.

      ssh é o comando padrão para abrir uma conexão SSH, mas quando usado com a diretiva -L, você pode especificar que uma dada porta no host local (ou seja, sua máquina local) será encaminhada para um dado host e porta no host remoto (neste caso, seu servidor). Isso significa que o que estiver sendo executado na porta especificada no servidor remoto (8888, porta padrão do Jupyter Notebook) aparecerá na porta especificada no seu computador local (8000 no comando exemplo).

      Para estabelecer seu próprio túnel SSH, execute o seguinte comando. Sinta-se à vontade para alterar a porta 8000 para outra que você queira se, por exemplo, a 8000 estiver em uso por outro processo. É recomendável que você utilize uma porta maior ou igual a 8000, uma vez que é pouco provável que esses números de porta sejam usados por outro processo. Certifique-se de incluir o endereço IP do seu próprio servidor e o nome do usuário não-root do seu servidor:

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

      Se não houver erros neste comando, ele irá logar você no seu servidor remoto. A partir daí, ative o ambiente virtual:

      • source ~/environments/my_env/bin/activate

      Então, execute o aplicativo Jupyter Notebook:

      Para se conectar ao Jupyter Notebook, utilize seu navegador Web favorito para navegar até a porta local no host local: http://localhost:8000. Agora que você está conectado ao Jupyter Notebook, continue para o Passo 4 para aprender a usá-lo.

      Tunelamento SSH utilizando Windows e PuTTY

      O PuTTY é um cliente SSH de código aberto para o Windows que pode ser usado para se conectar ao seu servidor. Após baixar e instalar o PuTTY na sua máquina Windows (tal como descrito no tutorial pré-requisito), abra o programa e digite o URL ou endereço IP do seu servidor, como mostrado aqui:

      Enter server URL or IP into Putty

      Em seguida, clique em + SSH ao final do painel esquerdo, e então clique em Tunnels. Nesta janela, digite a porta que você quiser usar para acessar o Jupyter na sua máquina local (8000 ). É recomendável que você utilize uma porta maior ou igual a 8000, uma vez que é pouco provável que esses números de porta sejam usados por outro processo. Se 8000 é usado por outro processo, no entanto, selecione um número de porta diferente e não utilizado. Em seguida, configure o destino como localhost:8888, uma vez que a porta 8888 é aquela na qual o Jupyter Notebook está funcionando. Então, clique no botão Add e as portas devem aparecer no campo Forwarded ports:

      Configure SSH tunnel in Putty

      Finalmente, clique no botão Open. Isso irá conectar sua máquina ao servidor através do SSH e ligar as portas desejadas. Se nenhum erro aparecer, vá em frente e ative seu ambiente virtual:

      • source ~/environments/my_env/bin/activate

      Então, execute o Jupyter Notebook:

      Em seguida, navegue até a porta local no seu navegador Web favorito, por exemplo http://localhost:8000 (ou qualquer número de porta que você escolheu), para se conectar à instância do Jupyter Notebook que está sendo executada no servidor. Agora que você está conectado ao Jupyter Notebook, continue para o Passo 4 para aprender a usá-lo.

      Passo 4 — Usando o Jupyter Notebook

      Quando acessado através de um navegador Web, o Jupyter Notebook fornece um Painel do Notebook, que atua como um navegador de arquivos e dá a você uma interface para criar, editar e explorar notebooks. Pense nestes notebooks como documentos (salvos com uma extensão de arquivo .ipynb) que você pode preencher com qualquer número de células individuais. Cada célula possui um editor de texto interativo que pode ser usado para executar códigos ou escrever texto renderizado. Além disso, os notebooks permitem que você escreva e execute equações, inclua outras mídias valiosas, como imagens ou gráficos interativos, e eles podem ser exportados e compartilhados em vários formatos (.ipyb, .pdf, .py). Para ilustrar algumas destas funções, vamos criar um arquivo de notebook a partir do Painel do Notebook, escrever um quadro de texto simples com uma equação, e executar um código básico de Python 3.

      Até este ponto, você deve ter se conectado ao servidor utilizando um túnel SSH e iniciado o aplicativo Jupyter Notebook do seu servidor. Após navegar para http://localhost:8000, você será apresentado com uma página de login:

      Jupyter Notebook login screen

      No campo Password or token ao topo, digite o token exibido no resultado após você executar jupyter notebook do seu 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] . . .

      De forma alternativa, você pode copiar aquele URL do resultado do seu terminal e colá-lo na barra de endereço do seu navegador.

      Automaticamente, o Jupyter Notebook irá mostrar todos os arquivos e pastas armazenados no diretório do qual ele está sendo executado. Crie um novo arquivo de notebook clicando em New então Python 3 no canto superior direito do Painel Notebook:

      Create a new Python3 notebook

      Dentro deste novo notebook, mude a primeira célula para que aceite a sintaxe markdown clicando em Cell > Cell Type > Markdown na barra de navegação no topo. Além da remarcação, este Cell Type também permite que você escreva equações em LaTeX. Por exemplo, digite o seguinte na célula após alterá-la para markdown:

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

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

      Turn sample equation into rich text

      Você pode usar as células markdown para fazer anotações e documentar seu código.

      Agora, vamos implementar uma equação simples e imprimir o resultado. Clique em Insert > Insert Cell Below para inserir uma célula. Nesta nova célula, digite o seguinte código:

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

      Para executar o código, pressione CTRL + ENTER, e o resultado será o seguinte:

      Solve sample equation

      Estes são alguns exemplos relativamente simples do que você pode fazer com o Jupyter Notebook. No entanto, ele é um aplicativo muito poderoso com muitos casos de uso possíveis. A partir daqui, adicione algumas bibliotecas Python e utilize o notebook como você faria com qualquer outro ambiente de desenvolvimento Python.

      Conclusão

      Agora, você deve ser capaz de escrever códigos reprodutíveis Python e texto utilizando o Jupyter Notebook em funcionamento em um servidor remoto. Para fazer um tour rápido pelo Jupyter Notebook, clique em Help na barra de navegação superior e selecione o User Interface Tour como mostrado aqui:

      Finding Jupyter Notebook help tour

      Se você estiver interessado, encorajamos você a aprender mais sobre o Jupyter Notebook através da documentação do Projeto Jupyter. Além disso, você pode construir desenvolver o que você aprendeu neste tutorial aprendendo como programar em Python 3.



      Source link