One place for hosting & domains

      Prisma

      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

      How to Manually Set Up a Prisma Server on Ubuntu 18.04


      The author selected the Electronic Frontier Foundation to receive a donation as part of the Write for DOnations program.

      Introduction

      Prisma is a data layer that replaces traditional object-relational mapping tools (ORMs) in your application. Offering support for both building GraphQL servers as well as REST APIs, Prisma simplifies database access with a focus on type safety and enables declarative database migrations. Type safety helps reduce potential code errors and inconsistencies, while the declarative database migrations allow you to store your datamodel in version control. These features help developers reduce time spent focused on setting up database access, migrations, and data management workflows.

      You can deploy the Prisma server, which acts as a proxy for your database, in a number of ways and host it either remotely or locally. Through the Prisma service you can access your data and connect to your database with the GraphQL API, which allows realtime operations and the ability to create, update, and delete data. GraphQL is a query language for APIs that allows users to send queries to access the exact data they require from their server. The Prisma server is a standalone component that sits on top of your database.

      In this tutorial you will manually install a Prisma server on Ubuntu 18.04 and run a test GraphQL query in the GraphQL Playground. You will host your Prisma setup code and development locally — where you will actually build your application — while running Prisma on your remote server. By running through the installation manually, you will have a deeper understanding and customizability of the underlying infrastructure of your setup.

      While this tutorial covers the manual steps for deploying Prisma on an Ubuntu 18.04 server, you can also accomplish this in a more automated way with Docker Machine by following this tutorial on Prisma’s site.

      Note: The setup described in this section does not include features you would normally expect from production-ready servers, such as automated backups and active failover.

      Prerequisites

      To complete this tutorial, you will need:

      Step 1 — Starting the Prisma Server

      The Prisma CLI is the primary tool used to deploy and manage your Prisma services. To start the services, you need to set up the required infrastructure, which includes the Prisma server and a database for it to connect to.

      Docker Compose allows you to manage and run multi-container applications. You’ll use it to set up the infrastructure required for the Prisma service.

      You will begin by creating the docker-compose.yml file to store the Prisma service configuration on your server. You’ll use this file to automatically spin up Prisma, an associated database, and configure the necessary details, all in one step. Once the file is spun up with Docker Compose, it will configure the passwords for your databases, so be sure to replace the passwords for managementAPIsecret and MYSQL_ROOT_PASSWORD with something secure. Run the following command to create and edit the docker-compose.yml file:

      • sudo nano docker-compose.yml

      Add the following content to the file to define the services and volumes for the Prisma setup:

      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:
      

      This configuration does the following:

      • It launches two services: prisma-db and db.
      • It pulls in the latest version of Prisma. As of this writing, that is Prisma 1.20.
      • It sets the ports Prisma will be available on and specifies all of the credentials to connect to the MySQL database in the databases section.

      The docker-compose.yml file sets up the managementApiSecret, which prevents others from accessing your data with knowledge of your endpoint. If you are using this tutorial for anything but a test deployment, you should change the managementAPIsecret to something more secure. When you do, be sure to remember it so that you can enter it later during the prisma init process.

      This file also pulls in the MySQL Docker image and sets those credentials as well. For the purposes of this tutorial, this Docker Compose file spins up a MySQL image, but you can also use PostgreSQL with Prisma. Both Docker images are available on Docker hub:

      Save and exit the file.

      Now that you have saved all of the details, you can start the Docker containers. The -d command tells the containers to run in detached mode, meaning they’ll run in the background:

      • sudo docker-compose up -d

      This will fetch the Docker images for both prisma and mysql. You can verify that the Docker containers are running with the following command:

      You will see an output that looks similar to this:

      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
      

      With your Prisma server and database set up, you are now ready to work locally to deploy the Prisma service.

      Step 2 — Installing Prisma Locally

      The Prisma server provides the runtime environments for your Prisma services. Now that you have your Prisma server started, you can deploy your Prisma service. You will run these steps locally, not on your server.

      To start, create a separate folder to contain all of the Prisma files:

      Then move into that folder:

      You can install Prisma with Homebrew if you're using MacOS. To do this, run the following command to add the Prisma repository:

      You can then install Prisma with the following command:

      Or alternately, with npm:

      With Prisma installed locally, you are ready to bootstrap the new Prisma service.

      Step 3 — Creating the Configuration for a New Prisma Service

      After the installation, you can use prisma init to create the file structure for a new Prisma database API, which generates the files necessary to build your application with Prisma. Your endpoint will automatically be in the prisma.yml file, and datamodel.prisma will already contain a sample datamodel that you can query in the next step. The datamodel serves as the basis for your Prisma API and specifies the model for your application. At this point, you are only creating the files and the sample datamodel. You are not making any changes to the database until you run prisma deploy later in this step.

      Now you can run the following command locally to create the new file structure:

      After you run this command you will see an interactive prompt. When asked, select, Use other server and press 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

      You will then provide the endpoint of your server that is acting as the Prisma server. It will look something like: http://SERVER_IP_ADDRESS:4466. It is key that the endpoint begins with http (or https) and has the port number indicated.

      Output

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

      For the management API secret, enter in the phrase or password that you indicated earlier in the configuration file:

      Output

      Enter the management API secret my-secret

      For the subsequent options, you can choose the default variables by pressing ENTER for the service name and service stage:

      Output

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

      You will also be given a choice on a programming language for the Prisma client. In this case, you can choose your preferred language. You can read more about the client here.

      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

      Once you have completed the prompt, you will see the following output that confirms the selections you made:

      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

      Move into the hello-world directory:

      Sync these changes to your server with prisma deploy. This sends the information to the Prisma server from your local machine and creates the Prisma service on the Prisma server:

      Note: Running prisma deploy again will update your Prisma service.

      Your output will look something like:

      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://SERVER_IP_ADDRESS:4466/hello-world/dev WS: ws://SERVER_IP_ADDRESS:4466/hello-world/dev

      The output shows that Prisma has updated your database according to your datamodel (created in the prisma init step) with a type User. Types are an essential part of a datamodel; they represent an item from your application, and each type contains multiple fields. For your datamodel the associated fields describing the user are: the user’s ID, name, time they were created, and time they were updated.

      If you run into issues at this stage and get a different output, double check that you entered all of the fields correctly during the interactive prompt. You can do so by reviewing the contents of the prisma.yml file.

      With your Prisma service running, you can connect to two different endpoints:

      • The management interface, available at http://SERVER_IP_ADDRESS:4466/management, where you can manage and deploy Prisma services.

      • The GraphQL API for your Prisma service, available at http://SERVER_IP_ADDRESS:4466/hello-world/dev.

      GraphQL API exploring _Your Project_

      You have successfully set up and deployed your Prisma server. You can now explore queries and mutations in GraphQL.

      Step 4 — Running an Example Query

      To explore another Prisma use case, you can experiment with the GraphQL playground tool, which is an open-source GraphQL integrated development environment (IDE) on your server. To access it, visit your endpoint in your browser from the previous step:

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

      A mutation is a GraphQL term that describes a way to modify — create, update, or delete (CRUD) — data in the backend via GraphQL. You can send a mutation to create a new user and explore the functionality. To do this, run the following mutation in the left-hand side of the page:

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

      Once you press the play button, you will see the results on the right-hand side of the page.
      GraphQL Playground Creating a New User

      Subsequently, if you want to look up a user by using the ID column in the database, you can run the following query:

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

      You now have a Prisma server and service up and running on your server, and you have run test queries in GraphQL's IDE.

      Conclusion

      You have a functioning Prisma setup on your server. You can see some additional Prisma use cases and next steps in the Getting Started Guide or explore Prisma's feature set in the Prisma Docs. Once you have completed all of the steps in this tutorial, you have a number of options to verify your connection to the database, one possibility is using the Prisma Client.



      Source link