Como Configurar um Banco de Dados Remoto para Otimizar o Desempenho do Site com o MySQL no Ubuntu 18.04

Introdução

À medida que sua aplicação ou site cresce, pode chegar um momento em que você superou a configuração atual do seu servidor. Se você estiver hospedando o seu servidor web e o back-end do banco de dados na mesma máquina, pode ser uma boa ideia separar essas duas funções para que cada uma possa operar em seu próprio hardware e compartilhar a carga de responder às solicitações dos visitantes.

Neste guia, veremos como configurar um servidor de banco de dados MySQL remoto ao qual sua aplicação web pode se conectar. Usaremos o WordPress como exemplo para ter algo para trabalhar, mas a técnica é amplamente aplicável a qualquer aplicação suportada pelo MySQL.

Pré-requisitos

Antes de iniciar este tutorial, você precisará de:

  • Dois servidores Ubuntu 18.04. Cada um deles deve ter um usuário não-root com privilégios sudo e um firewall UFW habilitado, conforme descrito em nosso tutorial de Configuração Inicial de servidor com Ubuntu 18.04. Um desses servidores hospedará seu back-end MySQL e, ao longo deste guia, o chamaremos de servidor de banco de dados. O outro se conectará ao seu servidor de banco de dados remotamente e atuará como seu servidor web; da mesma forma, iremos nos referir a ele como servidor web ao longo deste guia.
  • Nginx e PHP instalado em seu servidor web. Nosso tutorial How To Install Linux, Nginx, MySQL, PHP (LEMP stack) in Ubuntu 18.04 o guiará no processo, mas observe que você deve pular o Passo 2 deste tutorial, que se concentra na instalação do MySQL, pois você instalará o MySQL no seu servidor de banco de dados.
  • MySQL instalado em seu servidor de banco de dados. Siga o tutorial Como Instalar o MySQL no Ubuntu 18.04 para configurar isso.
  • Opcionalmente (mas altamente recomendado), certificados TLS/SSL da Let’s Encrypt instalados em seu servidor web. Você precisará comprar um nome de domínio e ter registros DNS configurados para seu servidor, mas os certificados em si são gratuitos. Nosso guia Como Proteger o Nginx com o Let’s Encrypt no Ubuntu 18.04 lhe mostrará como obter esses certificados.

Passo 1 — Configurando o MySQL para Escutar Conexões Remotas

Ter os dados armazenados em um servidor separado é uma boa maneira de expandir elegantemente após atingir o limite máximo de desempenho de uma configuração de uma única máquina. Ela também fornece a estrutura básica necessária para balancear a carga e expandir sua infraestrutura ainda mais posteriormente. Após instalar o MySQL, seguindo o tutorial de pré-requisitos, você precisará alterar alguns valores de configuração para permitir conexões a partir de outros computadores.

A maioria das mudanças na configuração do servidor MySQL pode ser feita no arquivo mysqld.cnf, que é armazenado no diretório /etc/mysql/mysql.conf.d/ por padrão. Abra este arquivo em seu servidor de banco de dados com privilégios de root em seu editor preferido. Aqui, iremos usar o nano:

  • sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Este arquivo é dividido em seções indicadas por labels entre colchetes ([ e ]). Encontre a seção com o label mysqld:

/etc/mysql/mysql.conf.d/mysqld.cnf
. . . [mysqld] . . . 

Nesta seção, procure um parâmetro chamado bind-address. Isso informa ao software do banco de dados em qual endereço de rede escutar as conexões.

Por padrão, isso está definido como 127.0.0.1, significando que o MySQL está configurado para escutar apenas conexões locais. Você precisa alterar isso para fazer referência a um endereço IP externo onde seu servidor pode ser acessado.

Se os dois servidores estiverem em um datacenter com recursos de rede privada, use o IP da rede privada do seu servidor de banco de dados. Caso contrário, você pode usar seu endereço IP público:

/etc/mysql/mysql.conf.d/mysqld.cnf
[mysqld] . . . bind-address = ip_do_servidor_de_banco_de_dados 

Como você se conectará ao seu banco de dados pela Internet, é recomendável que você exija conexões criptografadas para manter seus dados seguros. Se você não criptografar sua conexão MySQL, qualquer pessoa na rede poderá fazer sniff por informações confidenciais entre seus servidores web e de banco de dados. Para criptografar conexões MySQL, adicione a seguinte linha após a linha bind-address que você acabou de atualizar:

/etc/mysql/mysql.conf.d/mysqld.cnf
[mysqld] . . . require_secure_transport = on . . . 

Salve e feche o arquivo quando terminar. Se você estiver usando nano, faça isso pressionando CTRL+X, Y e, em seguida, ENTER.

Para que as conexões SSL funcionem, você precisará criar algumas chaves e certificados. O MySQL vem com um comando que os configura automaticamente. Execute o seguinte comando, que cria os arquivos necessários. Ele também os torna legíveis pelo servidor MySQL, especificando o UID do usuário mysql:

  • sudo mysql_ssl_rsa_setup --uid=mysql

Para forçar o MySQL a atualizar sua configuração e ler as novas informações de SSL, reinicie o banco de dados:

  • sudo systemctl restart mysql

Para confirmar que o servidor agora está escutando na interface externa, execute o seguinte comando netstat:

  • sudo netstat -plunt | grep mysqld
Output
tcp 0 0 ip_do_servidor_de_banco_de_dados:3306 0.0.0.0:* LISTEN 27328/mysqld

O netstat imprime estatísticas sobre o sistema de rede do seu servidor. Esta saída nos mostra que um processo chamado mysqld está anexado ao ip_do_servidor_de_banco_de_dados na porta 3306, a porta padrão do MySQL, confirmando que o servidor está escutando na interface apropriada.

Em seguida, abra essa porta no firewall para permitir o tráfego através dela:

  • sudo ufw allow mysql

Essas são todas as alterações de configuração que você precisa fazer no MySQL. A seguir, veremos como configurar um banco de dados e alguns perfis de usuário, um dos quais você usará para acessar o servidor remotamente.

Passo 2 — Configurando um Banco de Dados para o WordPress e Credenciais Remotas

Embora o próprio MySQL agora esteja escutando em um endereço IP externo, atualmente não há usuários ou bancos de dados habilitados para controle remoto configurados. Vamos criar um banco de dados para o WordPress e um par de usuários que possam acessá-lo.

Comece conectando-se ao MySQL como o usuário root do MySQL:

  • sudo mysql

Nota: Se você tiver a autenticação por senha ativada, conforme descrito no Passo 3 do pré-requisito do tutorial do MySQL, você precisará usar o seguinte comando para acessar o shell do MySQL:

  • mysql -u root -p

Depois de executar este comando, você será solicitado a fornecer sua senha de root do MySQL e, após inseri-la, receberá um novo prompt mysql>.

No prompt do MySQL, crie um banco de dados que o WordPress usará. Pode ser útil atribuir a esse banco de dados um nome reconhecível para que você possa identificá-lo facilmente mais tarde. Aqui, vamos chamá-lo de wordpress:

  • CREATE DATABASE wordpress;

Agora que você criou seu banco de dados, você precisará criar um par de usuários. Criaremos um usuário somente local e um usuário remoto vinculado ao endereço IP do servidor web.

Primeiro, crie seu usuário local, wpuser, e faça com que esta conta corresponda apenas às tentativas de conexão local usando localhost na declaração:

  • CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'senha';

Em seguida, conceda a esta conta acesso total ao banco de dados wordpress:

  • GRANT ALL PRIVILEGES ON wordpress.* TO 'wpuser'@'localhost';

Agora, esse usuário pode executar qualquer operação no banco de dados do WordPress, mas essa conta não pode ser usada remotamente, pois corresponde apenas às conexões da máquina local. Com isso em mente, crie uma conta complementar que corresponda às conexões exclusivamente do seu servidor web. Para isso, você precisará do endereço IP do seu servidor web.

Observe que você deve usar um endereço IP que utilize a mesma rede que você configurou no seu arquivo mysqld.cnf. Isso significa que, se você especificou um IP de rede privada no arquivo mysqld.cnf, precisará incluir o IP privado do seu servidor web nos dois comandos a seguir. Se você configurou o MySQL para usar a internet pública, você deve fazer isso corresponder ao endereço IP público do servidor web.

  • CREATE USER 'remotewpuser'@'ip_do_servidor_web' IDENTIFIED BY 'senha';

Depois de criar sua conta remota, conceda a ela os mesmos privilégios que o usuário local:

  • GRANT ALL PRIVILEGES ON wordpress.* TO 'remotewpuser'@'ip_do_servidor_web';

Por fim, atualize os privilégios para que o MySQL saiba começar a usá-los:

  • FLUSH PRIVILEGES;

Então saia do prompt do MySQL digitando:

  • exit

Agora que você configurou um novo banco de dados e um usuário habilitado remotamente, você pode testar se consegue se conectar ao banco de dados a partir do seu servidor web.

Passo 3 — Testando Conexões Remotas e Locais

Antes de continuar, é melhor verificar se você pode se conectar ao seu banco de dados tanto a partir da máquina local — seu servidor de banco de dados — quanto pelo seu servidor web.

Primeiro, teste a conexão local a partir do seu servidor de banco de dados tentando fazer login com sua nova conta:

  • mysql -u wpuser -p

Quando solicitado, digite a senha que você configurou para esta conta.

Se você receber um prompt do MySQL, então a conexão local foi bem-sucedida. Você pode sair novamente digitando:

  • exit

Em seguida, faça login no seu servidor web para testar as conexões remotas:

  • ssh sammy@ip_do_servidor_web

Você precisará instalar algumas ferramentas de cliente para MySQL em seu servidor web para acessar o banco de dados remoto. Primeiro, atualize o cache de pacotes local se você não tiver feito isso recentemente:

  • sudo apt update

Em seguida, instale os utilitários de cliente do MySQL:

  • sudo apt install mysql-client

Depois disso, conecte-se ao seu servidor de banco de dados usando a seguinte sintaxe:

  • mysql -u remotewpuser -h ip_do_servidor_de_banco_de_dados -p

Novamente, você deve certificar-se que está usando o endereço IP correto para o servidor de banco de dados. Se você configurou o MySQL para escutar na rede privada, digite o IP da rede privada do seu banco de dados. Caso contrário, digite o endereço IP público do seu servidor de banco de dados.

Você será solicitado a inserir a senha da sua conta remotewpuser. Depois de inseri-la, e se tudo estiver funcionando conforme o esperado, você verá o prompt do MySQL. Verifique se a conexão está usando SSL com o seguinte comando:

  • status

Se a conexão realmente estiver usando SSL, a linha SSL: indicará isso, como mostrado aqui:

Output
-------------- mysql Ver 14.14 Distrib 5.7.18, for Linux (x86_64) using EditLine wrapper Connection id: 52 Current database: Current user: remotewpuser@203.0.113.111 SSL: Cipher in use is DHE-RSA-AES256-SHA Current pager: stdout Using outfile: '' Using delimiter: ; Server version: 5.7.18-0ubuntu0.16.04.1 (Ubuntu) Protocol version: 10 Connection: 203.0.113.111 via TCP/IP Server characterset: latin1 Db characterset: latin1 Client characterset: utf8 Conn. characterset: utf8 TCP port: 3306 Uptime: 3 hours 43 min 40 sec Threads: 1 Questions: 1858 Slow queries: 0 Opens: 276 Flush tables: 1 Open tables: 184 Queries per second avg: 0.138 --------------

Depois de verificar que você pode se conectar remotamente, vá em frente e saia do prompt:

  • exit

Com isso, você verificou o acesso local e o acesso a partir do servidor web, mas não verificou se outras conexões serão recusadas. Para uma verificação adicional, tente fazer o mesmo em um terceiro servidor para o qual você não configurou uma conta de usuário específica para garantir que esse outro servidor não tenha o acesso concedido.

Observe que antes de executar o seguinte comando para tentar a conexão, talvez seja necessário instalar os utilitários de cliente do MySQL, como você fez acima:

  • mysql -u wordpressuser -h ip_do_servidor_de_banco_de_dados -p

Isso não deve ser concluído com êxito e deve gerar um erro semelhante a este:

Output
ERROR 1130 (HY000): Host '203.0.113.12' is not allowed to connect to this MySQL server

Isso é esperado, já que você não criou um usuário do MySQL que tem permissão para se conectar a partir deste servidor, e também é desejado, uma vez que você quer ter certeza de que seu servidor de banco de dados negará o acesso de usuários não autorizados ao seu servidor do MySQL.

Após testar com êxito sua conexão remota, você pode instalar o WordPress em seu servidor web.

Passo 4 — Instalando o WordPress

Para demonstrar os recursos do seu novo servidor MySQL com capacidade remota, passaremos pelo processo de instalação e configuração do WordPress — o popular sistema de gerenciamento de conteúdo — em seu servidor web. Isso exigirá que você baixe e extraia o software, configure suas informações de conexão e então execute a instalação baseada em web do WordPress.

No seu servidor web, faça o download da versão mais recente do WordPress para o seu diretório home:

  • cd ~
  • curl -O https://wordpress.org/latest.tar.gz

Extraia os arquivos, que criarão um diretório chamado wordpress no seu diretório home:

  • tar xzvf latest.tar.gz

O WordPress inclui um arquivo de configuração de exemplo que usaremos como ponto de partida. Faça uma cópia deste arquivo, removendo -sample do nome do arquivo para que ele seja carregado pelo WordPress:

  • cp ~/wordpress/wp-config-sample.php ~/wordpress/wp-config.php

Quando você abre o arquivo, sua primeira abordagem será ajustar algumas chaves secretas para fornecer mais segurança à sua instalação. O WordPress fornece um gerador seguro para esses valores, para que você não precise criar bons valores por conta própria. Eles são usados apenas internamente, portanto, não prejudicará a usabilidade ter valores complexos e seguros aqui.

Para obter valores seguros do gerador de chave secreta do WordPress, digite:

  • curl -s https://api.wordpress.org/secret-key/1.1/salt/

Isso imprimirá algumas chaves na sua saída. Você as adicionará momentaneamente ao seu arquivo wp-config.php:

Atenção! É importante que você solicite seus próprios valores únicos sempre. Não copie os valores mostrados aqui!

Output
define('AUTH_KEY', 'L4|2Yh(giOtMLHg3#] DO NOT COPY THESE VALUES %G00o|te^5YG@)'); define('SECURE_AUTH_KEY', 'DCs-k+MwB90/-E(=!/ DO NOT COPY THESE VALUES +WBzDq:7U[#Wn9'); define('LOGGED_IN_KEY', '*0kP!|VS.K=;#fPMlO DO NOT COPY THESE VALUES +&[%8xF*,18c @'); define('NONCE_KEY', 'fmFPF?UJi&(j-{8=$ - DO NOT COPY THESE VALUES CCZ?Q+_~1ZU~;G'); define('AUTH_SALT', '@qA7f}2utTEFNdnbEa DO NOT COPY THESE VALUES t}Vw+8=K%20s=a'); define('SECURE_AUTH_SALT', '%BW6s+d:7K?-`C%zw4 DO NOT COPY THESE VALUES 70U}PO1ejW+7|8'); define('LOGGED_IN_SALT', '-l>F:-dbcWof%4kKmj DO NOT COPY THESE VALUES 8Ypslin3~d|wLD'); define('NONCE_SALT', '4J(<`4&&F (WiK9K#] DO NOT COPY THESE VALUES ^ZikS`es#Fo:V6');

Copie a saída que você recebeu para a área de transferência e abra o arquivo de configuração no seu editor de texto:

  • nano ~/wordpress/wp-config.php

Encontre a seção que contém os valores fictícios para essas configurações. Será algo parecido com isto:

/wordpress/wp-config.php
. . . define('AUTH_KEY',         'put your unique phrase here'); define('SECURE_AUTH_KEY',  'put your unique phrase here'); define('LOGGED_IN_KEY',    'put your unique phrase here'); define('NONCE_KEY',        'put your unique phrase here'); define('AUTH_SALT',        'put your unique phrase here'); define('SECURE_AUTH_SALT', 'put your unique phrase here'); define('LOGGED_IN_SALT',   'put your unique phrase here'); define('NONCE_SALT',       'put your unique phrase here'); . . . 

Exclua essas linhas e cole os valores que você copiou a partir da linha de comando.

Em seguida, insira as informações de conexão para seu banco de dados remoto. Essas linhas de configuração estão na parte superior do arquivo, logo acima de onde você colou suas chaves. Lembre-se de usar o mesmo endereço IP que você usou no teste de banco de dados remoto anteriormente:

/wordpress/wp-config.php
. . . /** The name of the database for WordPress */ define('DB_NAME', 'wordpress');  /** MySQL database username */ define('DB_USER', 'remotewpuser');  /** MySQL database password */ define('DB_PASSWORD', 'password');  /** MySQL hostname */ define('DB_HOST', 'db_server_ip'); . . . 

E, finalmente, em qualquer lugar do arquivo, adicione a seguinte linha que diz ao WordPress para usar uma conexão SSL para o nosso banco de dados MySQL:

/wordpress/wp-config.php
define('MYSQL_CLIENT_FLAGS', MYSQLI_CLIENT_SSL); 

Salve e feche o arquivo.

Em seguida, copie os arquivos e diretórios encontrados no diretório ~/wordpress para a raiz de documentos do Nginx. Observe que este comando inclui a flag -a para garantir que todas as permissões existentes sejam transferidas:

  • sudo cp -a ~/wordpress/* /var/www/html

Depois disso, a única coisa a fazer é modificar a propriedade do arquivo. Altere a propriedade de todos os arquivos na raiz de documentos para www-data, o usuário padrão do servidor web do Ubuntu:

  • sudo chown -R www-data:www-data /var/www/html

Com isso, o WordPress está instalado e você está pronto para executar sua rotina de configuração baseada em web.

Passo 5 — Configurando o WordPress Através da Interface Web

O WordPress possui um processo de configuração baseado na web. Conforme você avança, ele fará algumas perguntas e instalará todas as tabelas necessárias no seu banco de dados. Aqui, abordaremos as etapas iniciais da configuração do WordPress, que você pode usar como ponto de partida para criar seu próprio site personalizado que usa um back-end de banco de dados remoto.

Navegue até o nome de domínio (ou endereço IP público) associado ao seu servidor web:

http://example.com 

Você verá uma tela de seleção de idioma para o instalador do WordPress. Selecione o idioma apropriado e clique na tela principal de instalação:

WordPress install screen

Depois de enviar suas informações, você precisará fazer login na interface de administração do WordPress usando a conta que você acabou de criar. Você será direcionado para um painel onde poderá personalizar seu novo site WordPress.

Conclusão

Ao seguir este tutorial, você configurou um banco de dados MySQL para aceitar conexões protegidas por SSL a partir de uma instalação remota do WordPress. Os comandos e técnicas usados neste guia são aplicáveis a qualquer aplicação web escrita em qualquer linguagem de programação, mas os detalhes específicos da implementação serão diferentes. Consulte a documentação do banco de dados da aplicação ou linguagem para obter mais informações.

DigitalOcean Community Tutorials

Como Instalar o Go e Configurar um Ambiente de Programação Local no macOS

Introdução

Go é uma linguagem de programação que nasceu da frustração no Google. Os desenvolvedores precisavam escolher continuamente uma linguagem que fosse executada com eficiência, mas demoravam muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que era executada de forma ineficiente em produção. O Go foi projetado para ter todas as três características disponíveis ao mesmo tempo: compilação rápida, facilidade de programação e execução eficiente em produção.

Embora o Go seja uma linguagem de programação versátil que pode ser usada para muitos projetos de programação diferentes, ela é particularmente adequada para programas de rede/sistemas distribuídos e ganhou a reputação de ser “a linguagem da nuvem”. Ela se concentra em ajudar o programador moderno a fazer mais com um conjunto forte de ferramentas, removendo debates sobre formatação ao tornar o formato parte da especificação da linguagem, bem como ao facilitar o deploy ao compilar para um único binário. O Go é fácil de aprender, com um conjunto muito pequeno de palavras-chave, o que o torna uma ótima opção para iniciantes e igualmente para desenvolvedores experientes.

Este tutorial irá guiá-lo pela instalação do Go em sua máquina local com macOS e da configuração de um workspace de programação através da linha de comando.

Pré-requisitos

Você precisará de um computador com macOS com acesso administrativo e que esteja conectado à Internet.

Passo 1 — Abrindo o Terminal

Você estará concluindo a instalação e a configuração na linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar nos botões, você digitará texto e receberá retornos do seu computador por meio de texto também. A linha de comando, também conhecida como shell, pode ajudá-lo a modificar e automatizar muitas das tarefas que você faz em um computador todos os dias, e é uma ferramenta essencial para desenvolvedores de software.

O Terminal do macOS é um aplicativo que você pode usar para acessar a interface da linha de comando. Como qualquer outro aplicativo, você pode encontrá-lo indo até o Finder, navegando até a pasta Aplicativos e, em seguida, na pasta Utilitários. A partir daqui, dê um clique duplo no Terminal como qualquer outro aplicativo para abri-lo. Alternativamente, você pode usar o Spotlight mantendo pressionadas as teclas CMD e SPACE para localizar o Terminal digitando-o na caixa que aparece.

macOS Terminal

Existem muitos outros comandos do Terminal para aprender que podem permitir que você faça coisas mais poderosas. O artigo “An Introduction to the Linux Terminal” pode te orientar melhor com o terminal do Linux, que é semelhante ao teminal do macOS.

Agora que você abriu o Terminal, pode fazer o download e instalar o Xcode, um pacote de ferramentas de desenvolvedor que você precisará para instalar o Go.

Passo 2 — Instalando o Xcode

O Xcode é um integrated development environment ou ambiente de desenvolvimento integrado (IDE) composto de ferramentas de desenvolvimento de software para macOS. Você pode verificar se o Xcode já está instalado, digitando o seguinte na janela do Terminal:

  • xcode-select -p

A saída a seguir significa que o Xcode está instalado:

Output
/Library/Developer/CommandLineTools

Se você recebeu um erro em seu navegador web, instale o Xcode a partir da App Store e aceite as opções padrão.

Quando o Xcode estiver instalado, retorne à janela do Terminal. Em seguida, você precisará instalar o app separado de Ferramentas de Linha de Comando do Xcode, que pode ser feito digitando:

  • xcode-select --install

Neste ponto, o Xcode e seu app de Ferramentas de Linha de Comando estão totalmente instalados e estamos prontos para instalar o gerenciador de pacotes Homebrew.

Passo 3 — Instalando e Configurando o Homebrew

Embora o Terminal do macOS tenha muitas das funcionalidades dos Terminais Linux e de outros sistemas Unix, ele não é fornecido com um gerenciador de pacotes que acomoda as melhores práticas. Um gerenciador de pacotes é uma coleção de ferramentas de software que trabalham para automatizar processos de instalação que incluem instalação inicial de software, atualização e configuração de software, e remoção de software conforme necessário. Eles mantêm instalações em um local central e podem manter todos os pacotes de software no sistema em formatos comumente usados. Homebrew fornece ao macOS um sistema gerenciador de pacotes de software livre e de código aberto que simplifica a instalação de software no macOS.

Para instalar o Homebrew, digite isso na sua janela de Terminal:

  • /usr/bin/ruby -e "$ (curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

O Homebrew é feito em Ruby, assim ele irá modificar o caminho do Ruby do seu computador. O comando curl baixa um script da URL especificada. Este script explicará o que ele fará e, em seguida, fará uma pausa no processo para solicitar sua confirmação. Isso lhe fornece uma série de comentários sobre o que o script vai fazer no seu sistema e dá a você a oportunidade de verificar o processo.

Se você precisar digitar sua senha, observe que suas teclas não serão exibidas na janela do Terminal, mas serão gravadas. Basta pressionar a tecla return ou enter depois de inserir sua senha. Caso contrário, pressione a letra y para “sim” quando você for solicitado a confirmar a instalação.

Vamos dar uma olhada nas flags associadas ao comando curl:

  • A flag -f ou --fail informa à janela do Terminal para não dar saída de documento HTML nos erros de servidor.
  • A flag -s ou --silent silencia o curl para que ele não mostre o medidor de progresso, e combinada com a flag -S ou --show-error ela irá assegurar que curl mostre uma mensagem de erro se falhar.
  • A flag -L ou --location informará ao curl para refazer a solicitação para um novo local se o servidor informar que a página solicitada foi movida para um local diferente.

Quando o processo de instalação estiver concluído, colocaremos o diretório Homebrew no começo da variável de ambiente PATH. Isso garantirá que as instalações do Homebrew serão chamadas antes das ferramentas que o macOS possa selecionar automaticamente e que podem ser executadas em contraposição ao ambiente de desenvolvimento que estamos criando.

Você deve criar ou abrir o arquivo ~/.bash_profile com o editor de texto de linha de comando nano usando o comando nano:

  • nano ~/.bash_profile

Quando o arquivo abrir na janela do Terminal, escreva o seguinte:

export PATH=/usr/local/bin:$  PATH 

Para salvar suas alterações, mantenha pressionada a tecla CTRL e a letra o e, quando solicitado, pressione a tecla RETURN. Agora você pode sair do nano segurando a tecla CTRL e a letra x.

Ative essas alterações executando o seguinte no Terminal:

  • source ~/.bash_profile

Depois de fazer isso, as alterações feitas na variável de ambiente PATH entrarão em vigor.

Você pode ter certeza de que o Homebrew foi instalado com sucesso digitando:

  • brew doctor

Se nenhuma atualização for necessária neste momento, a saída do Terminal mostrará:

Output
Your system is ready to brew.

Caso contrário, você pode receber um aviso para executar outro comando, como brew update, para garantir que sua instalação do Homebrew esteja atualizada.

Uma vez que o Homebrew está pronto, você pode instalar o Go.

Passo 4 — Instalando o Go

Você pode usar o Homebrew para procurar por todos os pacotes disponíveis com o comando brew search. Para o propósito deste tutorial, você irá procurar por pacotes ou módulos relacionados ao Go:

  • brew search golang

Nota: Este tutorial não usa brew search go, pois isso retorna muitos resultados. Como go é uma palavra muito pequena e combinaria com muitos pacotes, tornou-se comum usar golang como termo de busca. Essa é uma prática comum quando se pesquisa na Internet por artigos relacionados ao Go também. O termo Golang nasceu a partir do domínio para o Go, que é golang.org.

O Terminal mostrará uma lista do que você pode instalar:

Output
golang golang-migrate

O Go estará entre os itens da lista. Vá em frente e instale-o:

  • brew install golang

A janela do Terminal lhe dará feedback sobre o processo de instalação do Go. Pode demorar alguns minutos antes da conclusão da instalação.

Para verificar a versão do Go que você instalou, digite o seguinte:

  • go version

Isso mostrará a versão específica do Go que está atualmente instalada, que por padrão será a versão mais atualizada e estável do Go disponível.

No futuro, para atualizar o Go, você pode executar os seguintes comandos para atualizar o Homebrew e depois atualizar o Go. Você não precisa fazer isso agora, pois acabou de instalar a versão mais recente:

  • brew update
  • brew upgrade golang

brew update atualizará as fórmulas para o próprio Homebrew, garantindo que você tenha as informações mais recentes sobre os pacotes que deseja instalar. brew upgrade golang atualizará o pacote golang para a sua última versão.

É uma boa prática garantir que sua versão do Go esteja atualizada.

Com o Go instalado no seu computador, você está pronto para criar um workspace para seus projetos de Go.

Passo 5 — Criando o seu Workspace Go

Agora que você tem o Xcode, Homebrew e Go instalados, você pode criar seu workspace de programação.

O workspace do Go conterá dois diretórios em sua raiz:

  • src: O diretório que contém os arquivos-fonte do Go. Um arquivo-fonte é um arquivo que você escreve usando a linguagem de programação Go. Arquivos-fonte são usados pelo compilador Go para criar um arquivo binário executável.
  • bin: O diretório que contém executáveis compilados e instalados pelas ferramentas Go. Executáveis são arquivos binários que são executados em seu sistema e executam tarefas. Estes são normalmente os programas compilados a partir do seu código-fonte ou outro código-fonte Go baixado.

O subdiretório src pode conter vários repositórios de controle de versão (tais como o Git, o Mercurial, e o Bazaar). Você verá diretórios como github.com, golang.org ou outros quando seu programa importar bibliotecas de terceiros. Se você estiver usando um repositório de código como o github.com, você também colocará seus projetos e arquivos-fonte nesse diretório. Isso permite uma importação canônica de código em seu projeto. As importações Canônicas são importações que fazem referência a um pacote completo, como o github.com/digitalocean/godo.

Aqui está como pode se parecer um workspace típico:

. ├── bin │   ├── buffalo                                      # comando executável │   ├── dlv                                          # comando executável │   └── packr                                        # comando executável └── src     └── github.com         └── digitalocean             └── godo                 ├── .git                            # metadados do repositório do Git                 ├── account.go                      # fonte do pacote                 ├── account_test.go                 # fonte do teste                 ├── ...                 ├── timestamp.go                 ├── timestamp_test.go                 └── util                     ├── droplet.go                     └── droplet_test.go 

O diretório padrão para o workspace Go a partir da versão 1.8 é o diretório home do usuário com um subdiretório go ou $ HOME/go. Se você estiver usando uma versão anterior à 1.8 do Go, ainda é considerado uma boa prática usar o local $ HOME/go para o seu workspace.

Execute o seguinte comando para criar a estrutura de diretórios para o seu workspace Go:

  • mkdir -p $ HOME/go/{bin,src}

A opção -p diz ao mkdir para criar todos os subdiretórios no diretório, mesmo que eles não existam atualmente. A utilização do {bin, src} cria um conjunto de argumentos para mkdir e diz para ele criar tanto o diretóriobin quanto o diretório src.

Isso garantirá que a seguinte estrutura de diretórios esteja em vigor:

└── $  HOME     └── go         ├── bin         └── src 

Antes do Go 1.8, era necessário definir uma variável de ambiente local chamada $ GOPATH. Embora não seja mais explicitamente exigido fazer isso, ainda é considerada uma boa prática, pois muitas ferramentas de terceiros ainda dependem da configuração dessa variável.

Você pode definir seu $ GOPATH adicionando-o ao seu ~/.bash_profile.

Primeiro, abra ~/.bash_profile com o nano ou seu editor de texto preferido:

  • nano ~/.bash_profile

Defina seu $ GOPATH adicionando o seguinte ao arquivo:

~/.bash_profile
export GOPATH=$  HOME/go 

Quando o Go compila e instala ferramentas, ele as coloca no diretório $ GOPATH/bin. Por conveniência, é comum adicionar o subdiretório /bin do workspace ao seu PATH no seu arquivo ~/.bash_profile:

~/.bash_profile
export PATH=$  PATH:$  GOPATH/bin 

Agora você deve ter as seguintes entradas no seu ~/.bash_profile:

~/.bash_profile
export GOPATH=$  HOME/go export PATH=$  PATH:$  GOPATH/bin 

Agora, isso permitirá que você execute todos os programas compilados ou baixados por meio das ferramentas Go em qualquer parte do seu sistema.

Para atualizar seu shell, execute o seguinte comando para carregar as variáveis globais que você acabou de criar:

  • . ~/.bash_profile

Você pode verificar que seu $ PATH está atualizado usando o comando echo e inspecionando a saída:

  • echo $ PATH

Você deve ver seu $ GOPATH/bin, que aparecerá no seu diretório home. Se você estivesse logado como sammy, você veria /Users/sammy/go/bin no caminho.

Output
/Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

Agora que você tem a raiz do workspace criada e sua variável de ambiente $ GOPATH definida, você pode criar seus projetos futuros com a seguinte estrutura de diretórios. Este exemplo assume que você está usando o github.com como seu repositório:

$  GOPATH/src/github.com/username/project 

Se você estivesse trabalhando no projeto https://github.com/digitalocean/godo, você iria colocá-lo no seguinte diretório:

$  GOPATH/src/github.com/digitalocean/godo 

Estruturar seus projetos dessa maneira tornará os projetos disponíveis com a ferramenta go get. Isso também ajudará a legibilidade mais tarde.

Você pode verificar isso usando o comando go get para buscar a biblioteca godo:

  • go get github.com/digitalocean/godo

Você pode ver se baixou com sucesso o pacote godo listando o diretório:

  • ls -l $ GOPATH/src/github.com/digitalocean/godo

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

Output
-rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -rw-r--r-- 1 sammy staff 4893 Apr 5 15:56 vpcs.go -rw-r--r-- 1 sammy staff 4091 Apr 5 15:56 vpcs_test.go

Neste passo, você criou um workspace Go e configurou as variáveis de ambiente necessárias. No próximo passo, você testará o workspace com algum código.

Passo 6 — Criando um Programa Simples

Agora que você tem o workspace Go configurado, é hora de criar um simples programa “Hello, World!”. Isso garantirá que o workspace esteja configurado corretamente e também lhe dará a oportunidade de se familiarizar com o Go.

Como estamos criando um único arquivo-fonte Go, e não um projeto real, não precisamos estar em nosso workspace para fazer isso.

A partir do seu diretório home, abra um editor de texto de linha de comando, como o nano, e crie um novo arquivo:

  • nano hello.go

Quando o arquivo de texto abrir no Terminal, digite seu programa:

package main  import "fmt"  func main() {     fmt.Println("Hello, World!") } 

Saia do nano pressionando as teclas control e x, e quando solicitado a salvar o arquivo, pressione y.

Este código usará o pacote fmt e chamará a função Println com Hello, World! como argumento. Isso fará com que a frase Hello, World! seja impressa no terminal quando o programa for executado.

Ao sair do nano e retornar ao seu shell, execute o programa:

  • go run hello.go

O programa hello.go que você acabou de criar fará com que o Terminal produza a seguinte saída:

Output
Hello, World!

Neste passo, você usou um programa básico para verificar se seu workspace Go está configurado corretamente.

Conclusão

Parabéns! Neste ponto, você tem um workspace de programação Go configurado em sua máquina local com macOS e pode começar um projeto de codificação!

DigitalOcean Community Tutorials

Como Instalar o Go e Configurar um Ambiente de Programação Local no Ubuntu 18.04

Introdução

Go é uma linguagem de programação que nasceu da frustração no Google. Os desenvolvedores precisavam escolher continuamente uma linguagem que fosse executada com eficiência, mas demoravam muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que era executada de forma ineficiente em produção. O Go foi projetado para ter todas as três características disponíveis ao mesmo tempo: compilação rápida, facilidade de programação e execução eficiente em produção.

Embora o Go seja uma linguagem de programação versátil que pode ser usada para muitos projetos de programação diferentes, ela é particularmente adequada para programas de rede/sistemas distribuídos e ganhou a reputação de ser “a linguagem da nuvem”. Ela se concentra em ajudar o programador moderno a fazer mais com um conjunto forte de ferramentas, removendo debates sobre formatação ao tornar o formato parte da especificação da linguagem, bem como ao facilitar o deploy ao compilar para um único binário. O Go é fácil de aprender, com um conjunto muito pequeno de palavras-chave, o que o torna uma ótima opção para iniciantes e igualmente para desenvolvedores experientes.

Este tutorial irá guiá-lo pela instalação e configuração de um workspace de programação com o Go via linha de comando. Este tutorial cobrirá explicitamente o procedimento de instalação para o Ubuntu 18.04, mas os princípios gerais podem se aplicar a outras distribuições Debian Linux.

Pré-requisitos

Você precisará de um computador ou máquina virtual com o Ubuntu 18.04 instalado, além de ter acesso administrativo a essa máquina e uma conexão à Internet. Você pode baixar este sistema operacional através da página de releases do Ubuntu 18.04.

Passo 1 — Configurando o Go

Neste passo, você instalará o Go fazendo o download da versão atual da página oficial de downloads do Go.

Para fazer isso, você vai querer encontrar a URL para o tarball do binário da versão atual. Você também vai querer anotar o hash SHA256 listado ao lado dele, pois você usará esse hash para verificar o arquivo baixado.

Você estará concluindo a instalação e a configuração na linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar nos botões, você digitará texto e receberá retornos do seu computador por meio de texto também.

A linha de comando, também conhecida como shell ou terminal, pode ajudá-lo a modificar e automatizar muitas das tarefas que você faz em um computador todos os dias e é uma ferramenta essencial para desenvolvedores de software. Existem muitos comandos de terminal para aprender que podem permitir que você faça coisas mais poderosas. Para mais informações sobre a linha de comando, confira o tutorial Introdução ao Terminal do Linux.

No Ubuntu 18.04, você pode encontrar o aplicativo Terminal clicando no ícone do Ubuntu no canto superior esquerdo da tela e digitando terminal na barra de pesquisa. Clique no ícone do aplicativo Terminal para abri-lo. Alternativamente, você pode pressionar as teclas CTRL,ALT e T no teclado simultaneamente para abrir o aplicativo Terminal automaticamente.

Ubuntu Terminal

Quando o terminal estiver aberto, você instalará manualmente os binários do Go. Embora você possa usar um gerenciador de pacotes, como o apt-get, percorrer as etapas de instalação manual o ajudará a entender as alterações de configuração necessárias ao sistema para ter um workspace Go válido.

Antes de baixar o Go, certifique-se de estar no diretório home (~):

  • cd ~

Use o curl para recuperar a URL do tarball que você copiou da página oficial de downloads do Go:

  • curl -O https://dl.google.com/go/go1.12.1.linux-amd64.tar.gz

Em seguida, use sha256sum para verificar o tarball:

  • sha256sum go1.12.1.linux-amd64.tar.gz

O hash que é exibido a partir da execução do comando acima deve corresponder ao hash que estava na página de downloads. Se não, então este não é um arquivo válido e você deve baixar o arquivo novamente.

Output
2a3fdabf665496a0db5f41ec6af7a9b15a49fbe71a85a50ca38b1f13a103aeec go1.12.1.linux-amd64.tar.gz

Em seguida, extraia o arquivo baixado e instale-o no local desejado no sistema. É considerado uma boa prática mantê-lo em /usr/local:

  • sudo tar -xvf go1.12.1.linux-amd64.tar.gz -C /usr/local

Você terá agora um diretório chamado go no diretório /usr/local. Em seguida, altere recursivamente o proprietário e o grupo deste diretório para root:

  • sudo chown -R root:root /usr/local/go

Isso protegerá todos os arquivos e garantirá que apenas o usuário root possa executar os binários do Go.

Nota: Embora /usr/local/go seja o local oficialmente recomendado, alguns usuários podem preferir ou exigir caminhos diferentes.

Nesta etapa, você baixou e instalou o Go na sua máquina Ubuntu 18.04. Na próxima etapa, você configurará seu workspace de Go.

Passo 2 — Criando seu Workspace de Go

Você pode criar seu workspace de programação agora que o Go está instalado. O workspace do Go conterá dois diretórios em sua raiz:

  • src: O diretório que contém os arquivos-fonte do Go. Um arquivo-fonte é um arquivo que você escreve usando a linguagem de programação Go. Arquivos-fonte são usados pelo compilador Go para criar um arquivo binário executável.
  • bin: O diretório que contém executáveis compilados e instalados pelas ferramentas Go. Executáveis são arquivos binários que são executados em seu sistema e executam tarefas. Estes são normalmente os programas compilados a partir do seu código-fonte ou outro código-fonte Go baixado.

O subdiretório src pode conter vários repositórios de controle de versão (tais como o Git, o Mercurial, e o Bazaar). Isso permite uma importação canônica de código em seu projeto. As importações canônicas são importações que fazem referência a um pacote completo, como o github.com/digitalocean/godo.

Você verá diretórios como github.com, golang.org ou outros quando seu programa importar bibliotecas de terceiros. Se você estiver usando um repositório de código como o github.com, você também colocará seus projetos e arquivos-fonte nesse diretório. Vamos explorar esse conceito mais adiante neste passo.

Aqui está como pode se parecer um workspace típico:

. ├── bin │   ├── buffalo                                      # comando executável │   ├── dlv                                          # comando executável │   └── packr                                        # comando executável └── src     └── github.com         └── digitalocean             └── godo                 ├── .git                            # metadados do repositório do Git                 ├── account.go                      # fonte do pacote                 ├── account_test.go                 # fonte do teste                 ├── ...                 ├── timestamp.go                 ├── timestamp_test.go                 └── util                     ├── droplet.go                     └── droplet_test.go 

O diretório padrão para o workspace Go a partir da versão 1.8 é o diretório home do usuário com um subdiretório go ou $ HOME/go. Se você estiver usando uma versão anterior à 1.8 do Go, ainda é considerado uma boa prática usar o local $ HOME/go para o seu workspace.

Execute o seguinte comando para criar a estrutura de diretórios para o seu workspace Go:

  • mkdir -p $ HOME/go/{bin,src}

A opção -p diz ao mkdir para criar todos os subdiretórios no diretório, mesmo que eles não existam atualmente. A utilização do {bin, src} cria um conjunto de argumentos para mkdir e diz para ele criar tanto o diretóriobin quanto o diretório src.

Isso garantirá que a seguinte estrutura de diretórios esteja em vigor:

└── $  HOME     └── go         ├── bin         └── src 

Antes do Go 1.8, era necessário definir uma variável de ambiente local chamada $ GOPATH. $ GOPATH diz ao compilador onde encontrar o código-fonte importado de terceiros, bem como qualquer código-fonte local que você tenha escrito. Embora não seja mais explicitamente exigido, ainda é considerada uma boa prática, pois muitas ferramentas de terceiros ainda dependem da configuração dessa variável.

Você pode definir seu $ GOPATH adicionando as variáveis globais ao seu ~/.profile. Você pode querer adicionar isto ao arquivo .zshrc ou .bashrc de acordo com a configuração do seu shell.

Primeiro, abra o ~/.profile com o nano ou seu editor de textos preferido:

  • nano ~/.profile

Configure seu $ GOPATH adicionando o seguinte ao arquivo:

~/.profile
export GOPATH=$  HOME/go 

Quando o Go compila e instala ferramentas, ele as coloca no diretório $ GOPATH/bin. Por conveniência, é comum adicionar o subdiretório /bin do workspace ao seu PATH no seu ~/.profile:

~/.profile
export PATH=$  PATH:$  GOPATH/bin 

Isso permitirá que você execute quaisquer programas compilados ou baixados por meio das ferramentas Go em qualquer parte do sistema.

Finalmente, você precisa adicionar o binário go ao seu PATH. Você pode fazer isso adicionando /usr/local/go/bin ao final da linha:

~/.profile
export PATH=$  PATH:$  GOPATH/bin:/usr/local/go/bin 

Adicionar /usr/local/go/bin ao seu $ PATH torna todas as ferramentas Go disponíveis em qualquer lugar do seu sistema.

Para atualizar seu shell, execute o seguinte comando para carregar as variáveis globais:

  • . ~/.profile

Você pode verificar se seu $ PATH está atualizado usando o comando echo e inspecionando a saída:

  • echo $ PATH

Você verá o seu $ GOPATH/bin que aparecerá no seu diretório pessoal. Se você está logado como root, você verá /root/go/bin no caminho.

Output
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

Você também verá o caminho para as ferramentas Go /usr/local/go/bin:

Output
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

Verifique a instalação, conferindo a versão atual do Go:

  • go version

E devemos receber uma saída assim:

Output
go version go1.12.1 linux/amd64

Agora que você tem a raiz do workspace criada e sua variável de ambiente $ GOPATH definida, você pode criar seus projetos futuros com a seguinte estrutura de diretórios. Este exemplo assume que você está usando o github.com como seu repositório:

$  GOPATH/src/github.com/username/project 

Então, como um exemplo, se você estivesse trabalhando no projeto https://github.com/digitalocean/godo, ele seria armazenado no seguinte diretório:

$  GOPATH/src/github.com/digitalocean/godo 

Esta estrutura de projeto disponibilizará projetos com a ferramenta go get. Também ajudará a legibilidade mais tarde. Você pode verificar isso usando o comando go get e buscar a biblioteca godo:

  • go get github.com/digitalocean/godo

Isto irá baixar o conteúdo da biblioteca godo e criar o diretório $ GOPATH/src/github.com/digitalocean/godo em sua máquina.

Você pode verificar se baixou com sucesso o pacote godo listando o diretório:

  • ll $ GOPATH/src/github.com/digitalocean/godo

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

Output
drwxr-xr-x 4 root root 4096 Apr 5 00:43 ./ drwxr-xr-x 3 root root 4096 Apr 5 00:43 ../ drwxr-xr-x 8 root root 4096 Apr 5 00:43 .git/ -rwxr-xr-x 1 root root 8 Apr 5 00:43 .gitignore* -rw-r--r-- 1 root root 61 Apr 5 00:43 .travis.yml -rw-r--r-- 1 root root 2808 Apr 5 00:43 CHANGELOG.md -rw-r--r-- 1 root root 1851 Apr 5 00:43 CONTRIBUTING.md . . . -rw-r--r-- 1 root root 4893 Apr 5 00:43 vpcs.go -rw-r--r-- 1 root root 4091 Apr 5 00:43 vpcs_test.go

Neste passo, você criou um workspace Go e configurou as variáveis de ambiente necessárias. No próximo passo, você testará o workspace com algum código.

Passo 3 — Criando um Programa Simples

Agora que você tem o workspace Go configurado, crie um programa “Hello, World!”. Isso garantirá que o workspace esteja configurado corretamente e também lhe dará a oportunidade de se familiarizar com o Go. Como estamos criando um único arquivo-fonte Go, e não um projeto real, não precisamos estar em nosso workspace para fazer isso.

A partir do seu diretório home, abra um editor de texto de linha de comando, como o nano, e crie um novo arquivo:

  • nano hello.go

Escreva seu programa em seu novo arquivo:

package main  import "fmt"  func main() {     fmt.Println("Hello, World!") } 

Este código usará o pacote fmt e chamará a função Println com Hello, World! como argumento. Isso fará com que a frase Hello, World! seja impressa no terminal quando o programa for executado.

Saia do nano pressionando as teclas CTRL e X. Quando solicitado a salvar o arquivo, pressione Y e depois ENTER.

Ao sair do nano e retornar ao seu shell, execute o programa:

go run hello.go 

O programa hello.go fará com que o terminal produza a seguinte saída:

Output
Hello, World!

Nesta etapa, você usou um programa básico para verificar se seu workspace Go está configurado corretamente.

Conclusão

Parabéns! Neste ponto, você tem um workspace de programação Go configurado em sua máquina Ubuntu e pode começar um projeto de codificação!

DigitalOcean Community Tutorials

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:

Passo 1 — Iniciando o Servidor Prisma

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:

  • sudo docker ps

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:

  • mkdir prisma

Mova-se pra essa pasta:

  • cd prisma

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:

  • brew tap prisma/prisma

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

  • brew install prisma

Ou, alternativamente com o npm:

  • npm install -g prisma

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:

  • prisma init hello-world

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:

  • cd 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:

  • prisma deploy

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

DigitalOcean Community Tutorials

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:

  • sudo apt update

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.

  • pip install jupyter

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:

  • jupyter notebook

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:

  • 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

DigitalOcean Community Tutorials