One place for hosting & domains

      Configurar

      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

      Como Configurar Manualmente um Servidor Prisma no Ubuntu 18.04


      A autora selecionou a Electronic Frontier Foundation para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Prisma é uma camada de dados que substitui as ferramentas tradicionais de mapeamento relacional de objeto (ORMs) em sua aplicação. Oferecendo suporte tanto para a construção de servidores GraphQL, bem como REST APIs, o Prisma simplifica o acesso ao banco de dados com foco em segurança de tipo e permite migrações de banco de dados declarativas. A segurança de tipo ajuda a reduzir possíveis erros e inconsistências de código, enquanto as migrações de banco de dados declarativas permitem armazenar seu modelo de dados no controle de versão. Esses recursos ajudam os desenvolvedores a reduzir o tempo gasto na configuração de acesso a bancos de dados, migrações e fluxos de trabalho de gerenciamento de dados.

      Você pode fazer o deploy do servidor Prisma, que atua como um proxy para seu banco de dados, de várias maneiras e hospedá-lo remotamente ou localmente. Através do serviço do Prisma, você pode acessar seus dados e se conectar ao seu banco de dados com a API GraphQL, que permite operações em tempo real e a capacidade de criar, atualizar e excluir dados. O GraphQL é uma linguagem de consulta para APIs que permite aos usuários enviar consultas para acessar os dados exatos que eles precisam de seu servidor. O servidor Prisma é um componente independente que fica acima do seu banco de dados.

      Neste tutorial, você irá instalar manualmente um servidor Prisma no Ubuntu 18.04 e executará uma consulta de teste GraphQL no GraphQL Playground. Você hospedará seu código de configuração e desenvolvimento Prisma localmente — onde você constrói de fato a sua aplicação — enquanto executa o Prisma no seu servidor remoto. Ao realizar a instalação manualmente, você terá uma compreensão e uma personalização mais detalhadas da infraestrutura subjacente de sua configuração.

      Embora este tutorial aborde as etapas manuais para implantar o Prisma em um servidor Ubuntu 18.04, você também pode realizar isso de uma forma mais automatizada com a Docker Machine, seguindo este tutorial no site do Prisma.

      Note: A configuração descrita nesta seção não inclui recursos que você normalmente esperaria em servidores prontos para produção, como backups automatizados e failover ativo.

      Pré-requisitos

      Para completar este tutorial, você vai precisar de:

      O Prisma CLI é a principal ferramenta usada para fazer o deploy e gerenciar seus serviços Prisma. Para iniciar os serviços, você precisa configurar a infraestrutura necessária, que inclui o servidor Prisma e um banco de dados para conexão.

      O Docker Compose lhe permite gerenciar e executar aplicações multi-container. Você o utilizará para configurar a infraestrutura necessária para o serviço Prisma.

      Você começará criando o arquivo docker-compose.yml para armazenar a configuração do serviço Prisma em seu servidor. Você usará esse arquivo para ativar automaticamente o Prisma, um banco de dados associado, e configurar os detalhes necessários, tudo em uma única etapa. Uma vez que o arquivo é executado com o Docker Compose, ele irá configurar as senhas para seus bancos de dados, portanto, certifique-se de substituir as senhas para managementAPIsecret e MYSQL_ROOT_PASSWORD por algo seguro. Execute o seguinte comando para criar e editar o arquivo docker-compose.yml:

      • sudo nano docker-compose.yml

      Adicione o seguinte conteúdo ao arquivo para definir os serviços e volumes para a configuração do Prisma:

      docker-compose.yml

      
      version: "3"
      services:
        prisma:
          image: prismagraphql/prisma:1.20
          restart: always
          ports:
            - "4466:4466"
          environment:
            PRISMA_CONFIG: |
              port: 4466
              managementApiSecret: my-secret
              databases:
                default:
                  connector: mysql
                  host: mysql
                  port: 3306
                  user: root
                  password: prisma
                  migrations: true
        mysql:
          image: mysql:5.7
          restart: always
          environment:
            MYSQL_ROOT_PASSWORD: prisma
          volumes:
            - mysql:/var/lib/mysql
      volumes:
        mysql:
      

      Essa configuração faz o seguinte:

      • Lança dois serviços: prisma-db e db.

      • Baixa a última versão do Prisma. No momento da escrita desse artigo, ela é o Prisma 1.20.

      • Define as portas em que o Prisma estará disponível e especifica todas as credenciais para se conectar ao banco de dados MySQL na seção databases.

      O arquivo docker-compose.yml configura o managementApiSecret, que impede que outras pessoas acessem seus dados com conhecimento do seu endpoint. Se você estiver usando este tutorial apenas algo que não seja um deployment de teste, altere o managementAPIsecret para algo mais seguro. Quando fizer isso, guarde isso para que você possa inseri-lo mais tarde durante o processo prisma init.

      Esse arquivo também extrai a imagem Docker do MySQL e define essas credenciais também. Para os propósitos deste tutorial, este arquivo Docker Compose cria uma imagem MySQL, mas você também pode usar o PostgreSQL com o Prisma. Ambas as imagens Docker estão disponíveis no Docker Hub:

      Salve e saia do arquivo.

      Agora que você salvou todos os detalhes, você pode iniciar os containers do Docker. O comando -d diz aos containers para serem executados no modo detached, o que significa que eles serão executados em segundo plano:

      • sudo docker-compose up -d

      Isso irá buscar as imagens do Docker para prisma e mysql. Você pode verificar se os containers do Docker estão sendo executados com o seguinte comando:

      Você verá uma saída semelhante a esta:

      CONTAINER ID        IMAGE                       COMMAND                  CREATED             STATUS              PORTS                    NAMES
      24f4dd6222b1        prismagraphql/prisma:1.12   "/bin/sh -c /app/sta…"   15 seconds ago      Up 1 second         0.0.0.0:4466->4466/tcp   root_prisma_1
      d8cc3a393a9f        mysql:5.7                   "docker-entrypoint.s…"   15 seconds ago      Up 13 seconds       3306/tcp                 root_mysql_1
      

      Com seu servidor Prisma e o banco de dados configurados, agora você está pronto para trabalhar localmente para fazer o deploy do serviço Prisma.

      Passo 2 — Instalando o Prisma Localmente

      O servidor Prisma fornece os ambientes de runtime para seus serviços Prisma. Agora que você tem seu servidor Prisma iniciado, você pode fazer o deploy do seu serviço Prisma. Você executará estas etapas localmente, não no seu servidor.

      Para começar, crie uma pasta separada que irá conter todos os arquivos do Prisma:

      Mova-se pra essa pasta:

      Você pode instalar o Prisma com o Homebrew se você estiver usando o MacOS. Para fazer isso, execute o seguinte comando para adicionar o repositório do Prisma:

      Você pode então instalar o Prisma com o seguinte comando:

      Ou, alternativamente com o npm:

      Com o Prisma instalado localmente, você está pronto para iniciar o novo serviço Prisma.

      Passo 3 — Criando a Configuração para um Novo Serviço Prisma

      Após a instalação, você pode usar o prisma init para criar a estrutura de arquivos para uma nova API de banco de dados Prisma, que gera os arquivos necessários para construir sua aplicação com o Prisma. Seu endpoint estará automaticamente no arquivo prisma.yml, e o datamodel.prisma já conterá um modelo de dados de amostra que você pode consultar na próxima etapa. O modelo de dados serve como base para sua API Prisma e especifica o modelo para sua aplicação. Neste ponto, você está criando apenas os arquivos e o modelo de dados de amostra. Você não está fazendo nenhuma alteração no banco de dados até executar o prisma deploy posteriormente nesta etapa.

      Agora você pode executar o seguinte comando localmente para criar a nova estrutura de arquivos:

      Depois de executar este comando, você verá um prompt interativo. Quando perguntado, selecione, Use other server e pressione ENTER:

      Output

      Set up a new Prisma server or deploy to an existing server? You can set up Prisma for local development (based on docker-compose) Use existing database Connect to existing database Create new database Set up a local database using Docker Or deploy to an existing Prisma server: Demo server Hosted demo environment incl. database (requires login) ❯ Use other server Manually provide endpoint of a running Prisma server

      Em seguida, você fornecerá o endpoint do seu servidor que está atuando como servidor Prisma. Será algo parecido com: http://IP_DO_SERVIDOR:4466. É importante que o endpoint comece com http (ou https) e tenha o número da porta indicado.

      Output

      Enter the endpoint of your Prisma server http://IP_DO_SERVIDOR:4466

      Para o segredo da API de gerenciamento, insira a frase ou senha que você indicou anteriormente no arquivo de configuração:

      Output

      Enter the management API secret my-secret

      Para as opções subseqüentes, você pode escolher as variáveis padrão pressionando ENTER para o service name e service stage:

      Output

      Choose a name for your service hello-world Choose a name for your stage dev

      Você também terá a opção de escolher uma linguagem de programação para o cliente Prisma. Nesse caso, você pode escolher sua linguagem preferida. Você pode ler mais sobre o cliente aqui.

      Output

      Select the programming language for the generated Prisma client (Use arrow keys) ❯ Prisma TypeScript Client Prisma Flow Client Prisma JavaScript Client Prisma Go Client Don't generate

      Depois de terminar o prompt, você verá a seguinte saída que confirma as seleções que você fez:

      Output

      Created 3 new files: prisma.yml Prisma service definition datamodel.prisma GraphQL SDL-based datamodel (foundation for database) .env Env file including PRISMA_API_MANAGEMENT_SECRET Next steps: 1. Open folder: cd hello-world 2. Deploy your Prisma service: prisma deploy 3. Read more about deploying services: http://bit.ly/prisma-deploy-services

      Vá para o diretório hello-world:

      Sincronize estas mudanças com o seu servidor usando prisma deploy. Isso envia as informações para o servidor Prisma a partir da sua máquina local e cria o serviço Prisma no servidor Prisma:

      Nota: A execução do prisma deploy novamente atualizará seu serviço Prisma.

      Sua saída será algo como:

      Output

      Creating stage dev for service hello-world ✔ Deploying service `hello-world` to stage 'dev' to server 'default' 468ms Changes: User (Type) + Created type `User` + Created field `id` of type `GraphQLID!` + Created field `name` of type `String!` + Created field `updatedAt` of type `DateTime!` + Created field `createdAt` of type `DateTime!` Applying changes 716ms Your Prisma GraphQL database endpoint is live: HTTP: http://IP_DO_SERVIDOR:4466/hello-world/dev WS: ws://IP_DO_SERVIDOR:4466/hello-world/dev

      A saída mostra que o Prisma atualizou seu banco de dados de acordo com o seu modelo de dados (criado na etapa prisma init) com um tipo User. Tipos são uma parte essencial de um modelo de dados; eles representam um item da sua aplicação, e cada tipo contém vários campos. Para o seu modelo de dados, os campos associados que descrevem o usuário são: o ID do usuário, o nome, a hora em que foram criados e o horário em que foram atualizados.

      Se você encontrar problemas nesse estágio e obtiver uma saída diferente, verifique novamente se digitou todos os campos corretamente durante o prompt interativo. Você pode fazer isso revisando o conteúdo do arquivo prisma.yml.

      Com seu serviço Prisma em execução, você pode se conectar a dois endpoints diferentes:

      • A interface de gerenciamento, disponível em http://IP_DO_SERVIDOR:4466/management, onde você pode gerenciar e fazer deployment de serviços Prisma.

      • A API GraphQL para o seu serviço Prisma, disponível em http://IP_DO_SERVIDOR:4466/hello-world/dev.

      Você configurou e fez o deployment com sucesso do seu servidor Prisma. Agora você pode explorar consultas e mutações no GraphQL.

      Passo 4 — Executando uma Consulta de Exemplo

      Para explorar outro caso de uso do Prisma, você pode experimentar em seu servidor a ferramenta GraphQL playground, que é um ambiente de desenvolvimento integrado open-source (IDE). Para acessá-lo, visite seu endpoint em seu navegador, da etapa anterior:

      http://IP_DO_SERVIDOR:4466/hello-world/dev
      

      Uma mutação é um termo do GraphQL que descreve uma maneira de modificar — criar, atualizar ou excluir (CRUD) — dados no backend via GraphQL. Você pode enviar uma mutação para criar um novo usuário e explorar a funcionalidade. Para fazer isso, execute a seguinte mutação no lado esquerdo da página:

      mutation {
        createUser(data: { name: "Alice" }) {
          id
          name
        }
      }
      

      Depois de pressionar o botão play, você verá os resultados no lado direito da página.

      Posteriormente, se você quiser procurar um usuário usando a coluna ID no banco de dados, poderá executar a seguinte consulta:

      query {
        user(where: { id: "cjkar2d62000k0847xuh4g70o" }) {
          id
          name
        }
      }
      

      Agora você tem um servidor Prisma e o serviço em funcionamento no servidor, e você executou consultas de teste no IDE do GraphQL.

      Conclusão

      Você tem uma configuração Prisma em funcionamento no seu servidor. Você pode ver alguns casos de uso adicionais do Prisma e os próximos passos no Guia de primeiros passos ou explorar o conjunto de recursos do Prisma no Prisma Docs. Depois de concluir todas as etapas deste tutorial, você tem várias opções para verificar sua conexão com o banco de dados, sendo que uma possibilidade é a utilização do Prisma Client.

      Por Etel Sverdlov



      Source link

      Como Configurar um Registro Privado do Docker no Ubuntu 18.04


      O autor selecionou a Apache Software Foundation para receber uma doação como parte do programa Write for DOnations

      Introdução

      O Registro Docker é uma aplicação que gerencia o armazenamento e a entrega de imagens de container do Docker. Os registros centralizam imagens de container e reduzem o tempo de criação para desenvolvedores. As imagens do Docker garantem o mesmo ambiente de runtime por meio da virtualização, mas a criação de uma imagem pode envolver um investimento de tempo significativo. Por exemplo, em vez de instalar dependências e pacotes separadamente para usar o Docker, os desenvolvedores podem baixar uma imagem compactada de um registro que contém todos os componentes necessários. Além disso, os desenvolvedores podem automatizar o envio de imagens para um registro usando ferramentas de integração contínua, tais como o TravisCI, para atualizar continuamente as imagens durante a produção e o desenvolvimento.

      O Docker também tem um registro público gratuito, Docker Hub, que pode hospedar suas imagens personalizadas do Docker, mas há situações em que você não deseja que sua imagem fique disponível publicamente. As imagens geralmente contém todo o código necessário para executar uma aplicação, portanto, é preferível usar um registro privado ao usar um software proprietário.

      Neste tutorial, você irá configurar e proteger seu próprio Registro Docker privado. Você irá usar o Docker Compose para definir configurações para executar suas aplicações Docker e o Nginx para encaminhar o tráfego do servidor de HTTPS para o container do Docker em execução. Depois de concluir este tutorial, você poderá enviar uma imagem do Docker personalizada para seu registro privado e baixar a imagem com segurança de um servidor remoto.

      Pré-requisitos

      Antes de iniciar este guia, você precisará do seguinte:

      • Dois servidores Ubuntu 18.04 configurados seguindo a Configuração Inicial de servidor com Ubuntu 18.04, incluindo um usuário sudo não-root e um firewall. Um servidor irá hospedar seu Registro Docker privado e o outro será o seu servidor cliente.

      • Docker e Docker-Compose instalados em ambos os servidores seguindo o tutorial How To Install Docker Compose on Ubuntu 18.04. Você só precisa concluir a primeira etapa deste tutorial para instalar o Docker Compose. Este tutorial explica como instalar o Docker como parte de seus pré-requisitos.

      • Nginx instalado no seu servidor de Registro Docker privado seguindo o tutoral Como Instalar o Nginx no Ubuntu 18.04.

      • Nginx protegido com o Let’s Encrypt em seu servidor de Registro Docker privado, seguindo o tutorial Como Proteger o Nginx com o Let’s Encrypt no Ubuntu 18.04. Certifique-se de redirecionar todo o tráfego de HTTP para HTTPS no Passo 4.

      • Um nome de domínio que resolve para o servidor que você está usando para o Registro de Docker privado. Você configurará isso como parte do pré-requisito para o Let’s Encrypt.

      Passo 1 — Instalando e Configurando o Registro Docker

      A ferramenta de linha de comando do Docker é útil para iniciar e gerenciar um ou dois containers Docker, mas, para um deployment completo, a maioria das aplicações em execução dentro de containers do Docker exige que outros componentes sejam executados em paralelo. Por exemplo, muitas aplicações web consistem em um servidor web, como o Nginx, que oferece e serve o código da aplicação, uma linguagem de script interpretada, como o PHP, e um servidor de banco de dados, como o MySQL.

      Com o Docker Compose, você pode escrever um arquivo .yml para definir a configuração de cada container e as informações que os containers precisam para se comunicarem uns com os outros. Você pode usar a ferramenta de linha de comando docker-compose para emitir comandos para todos os componentes que compõem a sua aplicação.

      O próprio Registro Docker é uma aplicação com vários componentes, portanto, você utilizará o Docker Compose para gerenciar sua configuração. Para iniciar uma instância do registro, você irá configurar um arquivo docker-compose.yml para definir o local onde seu registro armazenará seus dados.

      No servidor que você criou para hospedar seu Registro Docker privado, você pode criar um diretório docker-registry, mover-se para ele, e criar uma subpasta data com os seguintes comandos:

      • mkdir ~/docker-registry && cd $_
      • mkdir data

      Use o seu editor de texto para criar o arquivo de configuração docker-compose.yml:

      Adicione o seguinte conteúdo ao arquivo, que descreve a configuração básica para o Registro Docker:

      docker-compose.yml

      version: '3'
      
      services:
        registry:
          image: registry:2
          ports:
          - "5000:5000"
          environment:
            REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
          volumes:
            - ./data:/data
      

      A seção environment define uma variável de ambiente no container do Registro Docker com o caminho /data. A aplicação do Registro Docker verifica essa variável de ambiente quando é inicializada e, como resultado, começa a salvar seus dados na pasta /data.

      No entanto, como você incluiu a linha volumes: - ./data:/data, e o Docker irá começar a mapear o diretório /data daquele container para /data em seu servidor de registro. O resultado final é que os dados do Registro Docker são armazenados em ~/docker-registry/data no servidor do registro.

      A seção ports, com a configuração 5000:5000, diz ao Docker para mapear a porta 5000 no servidor para a porta 5000 no container em execução. Isso lhe permite enviar uma solicitação para a porta 5000 no servidor, e ter essa solicitação encaminhada para a aplicação do registro.

      Agora você pode iniciar o Docker Compose para verificar a configuração:

      Você verá barras de download em sua saída que mostram o Docker baixando a imagem do Registro Docker do próprio Docker Registry. Em um ou dois minutos, você verá uma saída semelhante à seguinte (as versões podem variar):

      Output of docker-compose up

      Starting docker-registry_registry_1 ... done Attaching to docker-registry_registry_1 registry_1 | time="2018-11-06T18:43:09Z" level=warning msg="No HTTP secret provided - generated random secret. This may cause problems with uploads if multiple registries are behind a load-balancer. To provide a shared secret, fill in http.secret in the configuration file or set the REGISTRY_HTTP_SECRET environment variable." go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="redis not configured" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="Starting upload purge in 20m0s" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="using inmemory blob descriptor cache" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2 registry_1 | time="2018-11-06T18:43:09Z" level=info msg="listening on [::]:5000" go.version=go1.7.6 instance.id=c63483ee-7ad5-4205-9e28-3e809c843d42 version=v2.6.2

      Você abordará a mensagem de aviso No HTTP secret provided posteriormente neste tutorial. A saída mostra que o container está iniciando. A última linha da saída mostra que ele começou a escutar com sucesso na porta 5000.

      Por padrão, o Docker Compose permanecerá aguardando sua entrada, então pressione CTRL+C para encerrar seu container do Registro Docker.

      Você configurou um Registro Docker completo, escutando na porta 5000. Nesse ponto, o registro não será iniciado, a menos que você o faça manualmente. Além disso, o Registro Docker não vem com nenhum mecanismo de autenticação integrado, por isso está atualmente inseguro e completamente aberto ao público. Nos passos quem seguem, você abordará essas preocupações de segurança.

      Passo 2 — Configurando o Encaminhamento de Porta no Nginx

      Você já tem HTTPS configurado em seu servidor de Registro Docker com Nginx, o que significa que agora você pode configurar o encaminhamento de porta do Nginx para a porta 5000. Depois de concluir esta etapa, você pode acessar seu registro diretamente em example.com.

      Como parte do pré-requisito para o guia Como Proteger o Nginx com o Let's Encrypt no Ubuntu 18.04, você já configurou o arquivo /etc/nginx/sites-available/example.com contendo a configuração do seu servidor.

      Abra o arquivo com seu editor de texto:

      sudo nano /etc/nginx/sites-available/example.com
      

      Encontre a linha location existente. Isso parecerá assim:

      /etc/nginx/sites-available/example.com

      ...
      location / {
        ...
      }
      ...
      

      Você precisa encaminhar o tráfego para a porta 5000, onde seu registro estará em execução. Você também deseja anexar cabeçalhos à solicitação para o registro, que fornecem informações adicionais do servidor com cada solicitação e resposta. Exclua o conteúdo da seção location e inclua o seguinte conteúdo nessa seção:

      /etc/nginx/sites-available/example.com

      ...
      location / {
          # Do not allow connections from docker 1.5 and earlier
          # docker pre-1.6.0 did not properly set the user agent on ping, catch "Go *" user agents
          if ($http_user_agent ~ "^(docker/1.(3|4|5(?!.[0-9]-dev))|Go ).*$" ) {
            return 404;
          }
      
          proxy_pass                          http://localhost:5000;
          proxy_set_header  Host              $http_host;   # required for docker client's sake
          proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
          proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
          proxy_set_header  X-Forwarded-Proto $scheme;
          proxy_read_timeout                  900;
      }
      ...
      

      A seção $http_user_agent verifica se a versão do Docker do cliente está acima de 1.5 e garante que o UserAgent não seja uma aplicação Go. Como você está usando a versão 2.0 do registro, os clientes mais antigos não são suportados. Para mais informações, você pode encontrar a configuração do cabeçalho do nginx em Docker's Registry Nginx guide.

      Salve e saia do arquivo. Aplique as alterações reiniciando o Nginx:

      • sudo service nginx restart

      Você pode confirmar que o Nginx está encaminhando o tráfego para a porta 5000 executando o registro:

      • cd ~/docker-registry
      • docker-compose up

      Em uma janela do navegador, abra a seguinte URL:

      https://example.com/v2
      

      Você verá um objeto JSON vazio, ou:

      {}
      

      No seu terminal, você verá uma saída semelhante à seguinte:

      Output of docker-compose up

      registry_1 | time="2018-11-07T17:57:42Z" level=info msg="response completed" go.version=go1.7.6 http.request.host=cornellappdev.com http.request.id=a8f5984e-15e3-4946-9c40-d71f8557652f http.request.method=GET http.request.remoteaddr=128.84.125.58 http.request.uri="/v2/" http.request.useragent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0.2 Safari/604.4.7" http.response.contenttype="application/json; charset=utf-8" http.response.duration=2.125995ms http.response.status=200 http.response.written=2 instance.id=3093e5ab-5715-42bc-808e-73f310848860 version=v2.6.2 registry_1 | 172.18.0.1 - - [07/Nov/2018:17:57:42 +0000] "GET /v2/ HTTP/1.0" 200 2 "" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0.2 Safari/604.4.7"

      Você pode ver da última linha que uma requisição GET foi feita para /v2/, que é o endpoint para o qual você enviou uma solicitação do seu navegador. O container recebeu a solicitação que você fez, do encaminhamento de porta, e retornou uma resposta de {}. O código 200 na última linha da saída significa que o container tratou a solicitação com sucesso.

      Agora que você configurou o encaminhamento de porta, é possível melhorar a segurança do seu registro.

      Passo 3 — Configurando a Autenticação

      Com o Nginx fazendo proxy das solicitações corretamente, agora você pode proteger seu registro com autenticação HTTP para gerenciar quem tem acesso ao seu Registro Docker. Para conseguir isso, você irá criar um arquivo de autenticação com o htpasswd e adicionará usuários a ele. A autenticação HTTP é rápida de configurar e segura em uma conexão HTTPS, que é o que o registro usará.

      Você pode instalar o pacote htpasswd executando o seguinte:

      • sudo apt install apache2-utils

      Agora você irá criar o diretório onde você armazenará nossas credenciais de autenticação e irá se mover para esse diretório. O $_ expande para o último argumento do comando anterior, neste caso ~/docker-registry/auth:

      • mkdir ~/docker-registry/auth && cd $_

      Em seguida, você irá criar o primeiro usuário da seguinte forma, substituindo nome_usuário pelo nome de usuário que deseja usar. A flag -B especifica criptografia bcrypt, que é mais segura que a criptografia padrão. Digite a senha quando solicitado:

      • htpasswd -Bc registry.password nome_usuário

      Nota: Para adicionar mais usuários execute novamente o comando anterior sem a opção -c (o c é para criar):

      • htpasswd registry.password nome_usuário

      A seguir, você irá editar o arquivo docker-compose.yml para dizer ao Docker para usar o arquivo que você criou para autenticar usuários.

      • cd ~/docker-registry
      • nano docker-compose.yml

      Você pode adicionar variáveis de ambiente e um volume para o diretório auth/ que você criou, editando o arquivo docker-compose.yml para informar ao Docker como você deseja autenticar usuários. Adicione o seguinte conteúdo destacado ao arquivo:

      docker-compose.yml

      version: '3'
      
      services:
        registry:
          image: registry:2
          ports:
          - "5000:5000"
          environment:
            REGISTRY_AUTH: htpasswd
            REGISTRY_AUTH_HTPASSWD_REALM: Registry
            REGISTRY_AUTH_HTPASSWD_PATH: /auth/registry.password
            REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
          volumes:
            - ./auth:/auth
            - ./data:/data
      

      Para REGISTRY_AUTH, você especificou htpasswd, que é o esquema de autenticação que você está utilizando, e definiu REGISTRY_AUTH_HTPASSWD_PATH para o caminho do arquivo de autenticação. Finalmente, REGISTRY_AUTH_HTPASSWD_REALM significa o nome do domínio do htpasswd.

      Agora você pode verificar se sua autenticação funciona corretamente, executando o registro e verificando se ele solicita um nome de usuário e uma senha.

      Em uma janela do navegador, abra https://example.com/v2.

      Depois de digitar o nome_usuário e a senha correspondente, você verá o {} mais uma vez. Você confirmou a configuração básica da autenticação: o registro só retornou o resultado depois que você digitou o nome de usuário e a senha corretos. Agora você já protegeu seu registro e pode continuar utilizando-o.

      Passo 4 — Iniciando o Registro Docker como um Serviço

      Você quer garantir que seu registro seja iniciado sempre que o sistema for inicializado. Se houver algum travamento imprevisto do sistema, você quer ter certeza de que o registro seja reiniciado quando o servidor for reinicializado. Abra o docker-compose.yml:

      Adicione a seguinte linha de conteúdo logo abaixo de registry::

      docker-compose.yml

      ...
        registry:
          restart: always
      ...
      

      Você pode iniciar seu registro como um processo em segundo plano, o que permitirá que você saia da sessão ssh e persista o processo:

      Com o seu registro em execução em segundo plano, agora você pode preparar o Nginx para uploads de arquivos.

      Passo 5 — Aumentando o Tamanho do Upload de Arquivos para o Nginx

      Antes de poder enviar uma imagem para o registro, você precisa garantir que o registro possa lidar com grandes uploads de arquivos. Embora o Docker divida os uploads de imagens grandes em camadas separadas, às vezes elas podem ter mais de 1GB. Por padrão, o Nginx tem um limite de 1MB para uploads de arquivos, então você precisa editar o arquivo de configuração do nginx e configurar o tamanho máximo de upload do arquivo para 2GB.

      • sudo nano /etc/nginx/nginx.conf

      Encontre a seção http e adicione a seguinte linha:

      /etc/nginx/nginx.conf

      ...
      http {
              client_max_body_size 2000M;
              ...
      }
      ...
      

      Por fim, reinicie o Nginx para aplicar as alterações de configuração:

      • sudo service nginx restart

      Agora você pode enviar imagens grandes para o seu Registro Docker sem erros no Nginx.

      Passo 6 — Publicando em seu Registro Docker Privado

      Agora você está pronto para publicar uma imagem no seu Registro Docker privado, mas primeiro é preciso criar uma imagem. Para este tutorial, você criará uma imagem simples baseada na imagem ubuntu do Docker Hub. O Docker Hub é um registro hospedado publicamente, com muitas imagens pré-configuradas que podem ser aproveitadas para "Dockerizar" rapidamente as aplicações. Usando a imagem ubuntu, você vai testar o envio e o download de imagens do seu registro.

      Do seu servidor cliente, crie uma imagem pequena e vazia para enviar para o seu novo registro. As flags -i e -t lhe fornecem acesso interativo ao shell no container:

      • docker run -t -i ubuntu /bin/bash

      Após o término do download, você estará dentro de um prompt do Docker, observe que o ID do container após root@ irá variar. Faça uma rápida mudança no sistema de arquivos criando um arquivo chamado SUCCESS. No próximo passo, você poderá usar esse arquivo para determinar se o processo de publicação foi bem-sucedido:

      Saia do container do Docker:

      O comando a seguir cria uma nova imagem chamada test-image com base na imagem já em execução, além de todas as alterações que você fez. No nosso caso, a adição do arquivo /SUCCESS está incluída na nova imagem.

      Faça o commit da alteração:

      • docker commit $(docker ps -lq) test-image

      Neste ponto, a imagem só existe localmente. Agora você pode enviá-la para o novo registro que você criou. Faça o login no seu Registro Docker:

      • docker login https://example.com

      Digite o nome_usuário e a senha correspondente de antes. Em seguida, você colocará uma tag na imagem com a localização do registro privado para enviar a ele:

      • docker tag test-image example.com/test-image

      Envie a imagem recém-marcada para o registro:

      • docker push example.com/test-image

      Sua saída será semelhante à seguinte:

      Output

      The push refers to a repository [example.com/test-image] e3fbbfb44187: Pushed 5f70bf18a086: Pushed a3b5c80a4eba: Pushed 7f18b442972b: Pushed 3ce512daaf78: Pushed 7aae4540b42d: Pushed ...

      Você verificou que seu registro trata a autenticação do usuário e permite que usuários autenticados enviem imagens ao registro. Em seguida, você confirmará que também é possível extrair ou baixar imagens do registro.

      Passo 7 — Baixando de seu Registro Docker Privado

      Retorne ao seu servidor de registro para que você possa testar o download da imagem a partir do seu servidor cliente. Também é possível testar isso a partir de um outro servidor.

      Faça o login com o nome de usuário e senha que você configurou anteriormente:

      • docker login https://example.com

      Agora você está pronto para baixar a imagem. Use seu nome de domínio e nome de imagem, que você marcou na etapa anterior:

      • docker login example.com/test-image

      O Docker irá baixar a imagem e retornar você ao prompt. Se você executar a imagem no servidor de registro, verá que o arquivo SUCCESS criado anteriormente está lá:

      • docker run -it example.com/test-image /bin/bash

      Liste seus arquivos dentro do shell bash:

      Você verá o arquivo SUCCESS que você criou para esta imagem:

      SUCCESS  bin  boot  dev  etc  home  lib  lib64  media   mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
      

      Você terminou de configurar um registro seguro para o qual os usuários podem enviar e baixar imagens personalizadas.

      Conclusão

      Neste tutorial, você configurou seu próprio Registro Docker privado e publicou uma imagem Docker. Como mencionado na introdução, você também pode usar o TravisCI ou uma ferramenta de CI semelhante para automatizar o envio diretamente para um registro privado. Ao aproveitar o Docker e os registros em seu fluxo de trabalho, você pode garantir que a imagem que contém o código resulte no mesmo comportamento em qualquer máquina, seja em produção ou em desenvolvimento. Para obter mais informações sobre como escrever arquivos do Docker, você pode ler o tutorial do Docker, que explica o processo.

      Por Young Kim



      Source link