One place for hosting & domains

      Nginx

      Como instalar o Linux, o Nginx, o MySQL, o PHP (pilha LEMP) no Ubuntu 18.04


      Introdução

      A pilha de software LEMP é um grupo de software que pode ser usado para atender páginas e aplicativos Web dinâmicos. Este é um acrônimo que descreve um sistema operacional Linux, com um servidor Web Nginx (se pronuncia “Engine-X). Os dados backend são armazenados no banco de dados MySQL e o processamento dinâmico é tratado pelo PHP.

      Este guia demonstra como instalar uma pilha LEMP em um servidor Ubuntu 18.04. O sistema operacional Ubuntu cuida do primeiro requisito. Vamos descrever como colocar o resto dos componentes em funcionamento.

      Pré-requisitos

      Antes de completar este tutorial, será necessário ter uma conta de usuário regular e sem root no seu servidor com privilégios sudo. Configure esta conta completando nosso guia de configuração inicial do servidor para o Ubuntu 18.04 .

      Assim que tiver seu usuário disponível, você está pronto para iniciar as etapas delineadas neste guia.

      Passo 1 — Como instalar o servidor Web Nginx

      Para mostrar páginas Web aos visitantes de nosso site, vamos usar o Nginx, um moderno e eficiente servidor Web.

      Todo software usado neste procedimento virão dos repositórios de pacote padrão do Ubuntu. Isso significa que podemos usar o conjunto de gerenciamento de pacotes apt para completar as instalações necessárias.

      Uma vez que essa é a primeira vez que vamos usar o apt para esta sessão, atualize o índice de pacotes do seu servidor. Em seguida, instale o servidor:

      • sudo apt update
      • sudo apt install nginx

      No Ubuntu 18.04, o Nginx está configurado para começar a executar após a instalação.

      Se tiver o firewall ufw funcionando como descrito no guia de configuração inicial, será necessário permitir as conexões ao Nginx. O Nginx registra-se com o ufw após a instalação, então o procedimento é bastante simples.

      É recomendável que habilite o perfil mais restritivo que ainda assim permitirá o tráfego que quiser. Como ainda não configurou o SSL para seu servidor neste guia, será necessário apenas permitir o tráfego na porta 80.

      Habilite isso digitando:

      • sudo ufw allow 'Nginx HTTP'

      Verifique a mudança executando:

      Este comando irá mostrar que o tráfego HTTP é permitido:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere Nginx HTTP ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) Nginx HTTP (v6) ALLOW Anywhere (v6)

      Com essas novas regras adicionadas no firewall, você pode testar se o servidor está funcionando acessando o nome do domínio do seu servidor ou endereço IP público no seu navegador Web.

      Se você não tiver um nome de domínio apontando no seu servidor e você não sabe o endereço IP público do seu servidor, é possível encontrá-lo executando o seguinte comando:

      • ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's//.*$//'

      Isso irá mostrar na tela alguns endereços IP. Você pode testar cada um deles em seu navegador Web.

      Como uma alternativa, verifique qual endereço IP está acessível, como visto por outras locações na internet:

      Digite o endereço que receber no seu navegador Web e ele irá levá-lo para a página inicial do Nginx:

      http://server_domain_or_IP
      

      Nginx default page

      Se ver a página acima, você instalou o Nginx com sucesso.

      Passo 2 — Como instalar o MySQL para gerenciar dados do site

      Agora que você tem um servidor Web, será necessário instalar o MySQL (um sistema de gerenciamento de banco de dados) para armazenar e gerenciar os dados para seu site.

      Instale o MySQL digitando:

      • sudo apt install mysql-server

      O software de banco de dados MySQL agora está instalado, mas sua configuração ainda não está completa.

      Para proteger a instalação, o MySQL vem com um script que irá perguntar se queremos modificar alguns padrões não-seguros. Inicie o script digitando:

      • sudo mysql_secure_installation

      Este script irá perguntar se deseja configurar o VALIDATE PASSWORD PLUGIN.

      Aviso: Ativar esta característica é uma decisão sua. Se habilitada, as senhas que não corresponderem o critério especificado serão rejeitadas pelo MySQL com um erro. Isso causará problemas caso utilize uma senha fraca em conjunto com o software que configura automaticamente as credenciais de usuário do MySQL, como os pacotes Ubuntu para o phpMyAdmin. É seguro deixar a validação desativada, mas sempre utilize senhas fortes e únicas para as credenciais do banco de dados.

      Responda Y para sim, ou qualquer outra coisa para continuar sem a habilitar.

      VALIDATE PASSWORD PLUGIN can be used to test passwords
      and improve security. It checks the strength of password
      and allows the users to set only those passwords which are
      secure enough. Would you like to setup VALIDATE PASSWORD plugin?
      
      Press y|Y for Yes, any other key for No:
      

      Se tiver habilitado a validação, o script também irá pedir a você para selecionar um nível de validação de senha. Lembre-se de que se digitar 2 para o níveis mais forte – receberá erros ao tentar definir qualquer senha que não contenha números, letras maiúsculas e minúsculas, e caracteres especiais, ou que se baseiam em palavras do dicionário comuns.

      There are three levels of password validation policy:
      
      LOW    Length >= 8
      MEDIUM Length >= 8, numeric, mixed case, and special characters
      STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file
      
      Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 1
      

      Em seguida, será solicitado que envie e confirme uma senha root:

      Please set the password for root here.
      
      New password:
      
      Re-enter new password:
      

      Para o resto das perguntas, pressione Y e clique na tecla ENTER em cada prompt. Isso removerá alguns usuários anônimos e o banco de dados teste, desativará os logins remotos ao root, e carregará essas novas regras para que o MySQL respeite imediatamente as alterações que fizemos.

      Note que os sistemas Ubuntu que rodam o MySQL 5.7 (e as versões posteriores), o usuário root MySQL está definido para autenticar usando o plug-in do auth_socket por padrão ao invés de um com uma senha. Isso permite maior segurança e a usabilidade na maioria dos casos, mas também pode complicar as coisas quando for necessário permitir que um programa externo (por exemplo, o phpMyAdmin) acesse o usuário.

      Se usar o plug-in auth_socket para acessar o MySQL se encaixar com seu fluxo de trabalho, vá para o Passo 3. Se, no entanto, preferir usar uma senha quando se conectar ao MySQL como root, será necessário alterar seu método de autenticação do auth_socket para o mysql_native_password. Para fazer isso, abra o prompt do MySQL do seu terminal:

      Em seguida, verifique quais os métodos de autenticação cada conta de usuário do seu MySQL utilizam com o seguinte comando:

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | | auth_socket | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost | | debian-sys-maint | *CC744277A401A7D25BE1CA89AFF17BF607F876FF | mysql_native_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 4 rows in set (0.00 sec)

      Neste exemplo, é possível ver que o usuário root autenticou usando o plug-in auth_socket. Para configurar a conta root para autenticar com uma senha, execute o comando ALTER USER. Certifique-se de trocar a senha por uma senha forte de sua escolha:

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Então, execute o comando FLUSH o qual diz para o servidor recarregar as tabelas de permissões e colocar as suas alterações em vigor:

      Verifique novamente os métodos de autenticação utilizados por cada um dos seus usuários para confirmar que *root *já não autentica utilizando o plug-in do auth_socket:

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | *3636DACC8616D997782ADD0839F92C1571D6D78F | mysql_native_password | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost | | debian-sys-maint | *CC744277A401A7D25BE1CA89AFF17BF607F876FF | mysql_native_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 4 rows in set (0.00 sec)

      Neste exemplo, é possível ver o resultado que agora o usuário root MySQL autentica utilizando uma senha. Assim que confirmar isso no seu servidor, saia do shell MySQL:

      Nota: Após configurar seu usuário root MySQL para autenticar com uma senha, você já não será capaz de acessar o MySQL com o comando sudo mysql usado anteriormente. Ao invés disso, execute o seguinte:

      Após digitar a senha que acabou de definir, você verá o prompt do MySQL.

      Neste ponto, seu sistema de banco de dados está configurado e você pode seguir em frente para a instalação do PHP.

      Passo 3 — Como instalar o PHP e configurar o Nginx para usar o Processo do PHP

      Agora você tem o Nginx instalado para servir suas páginas e o MySQL instalado para armazenar e gerenciar seus dados. No entanto, você ainda não tem nada instalado que possa gerar conteúdo dinâmico. Aqui é onde o PHP entra em jogo.

      Uma vez que o Nginx não contém o processamento nativo do PHP como outros servidores Web, você precisará instalar o php-fpm, que significa "gerenciador de processos fastCGI”. Diremos ao Nginx para passar os pedidos PHP para este software para processamento.

      Nota: Dependendo do seu fornecedor de nuvem, talvez seja necessário adicionar o repositório universe do Ubuntu que inclui o software de código aberto mantido pela comunidade Ubuntu, antes de instalar o pacote php-fpm. Faça isso digitando:**

      • sudo add-apt-repository universe

      Instale o módulo php-fpm junto com um pacote auxiliar adicional, php-mysql, que permitirá que o PHP se comunique com seu backend do banco de dados. A instalação irá puxar os arquivos principais e necessários do PHP. Faça isso digitando:

      • sudo apt install php-fpm php-mysql

      Agora você tem todos os componentes de pilha LEMP necessários instalados, mas ainda assim será necessário fazer algumas alterações de configuração para dizer ao Nginx para usar o processador PHP para conteúdo dinâmico.

      Isto é feito no nível de bloco do servidor ( os blocos do servidor são semelhantes aos hosts virtuais do Apache). Para fazer isso, abra um novo arquivo de configuração de bloco de servidor dentro do diretório /etc/nginx/sites-available/. Neste exemplo, o novo arquivo de configuração de bloco de servidor se chama example.com, embora você possa dar o nome que quiser:

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

      Ao editar um novo arquivo de configuração de bloco de servidor, ao invés de editar o padrão, você será capaz de restaurar facilmente a configuração padrão caso seja necessário.

      Adicione o seguinte conteúdo, que foi tomado e ligeiramente modificado do arquivo de configuração padrão do bloco de servidor, ao seu novo arquivo de configuração de bloco de servidor:

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

      server {
              listen 80;
              root /var/www/html;
              index index.php index.html index.htm index.nginx-debian.html;
              server_name example.com;
      
              location / {
                      try_files $uri $uri/ =404;
              }
      
              location ~ .php$ {
                      include snippets/fastcgi-php.conf;
                      fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
              }
      
              location ~ /.ht {
                      deny all;
              }
      }
      

      Aqui está o que cada um desses blocos de localização e diretrizes fazem:

      • listen — Define o que a porta Nginx irá escutar. Neste caso, ele irá escutar na porta 80, a porta padrão para o HTTP.
      • root— Define o documento root onde os arquivos apresentados pelo site são armazenados.
      • index— Configura o Nginx para dar prioridade a arquivos de serviço designados index.php quando um arquivo index é solicitado, se eles estiverem disponíveis.
      • server_name— Define qual bloco de servidor deve ser usado para um dado pedido ao seu servidor.** Aponte esta diretriz para o nome de domínio do seu servidor ou endereço IP público.**
      • location /— O primeiro bloco de localização inclui uma diretriz try_files, que verifica a existência de arquivos que correspondam a um pedido URI. Se o Nginx não puder encontrar o arquivo apropriado, ele irá retornar um erro 404.
      • location ~ .php$— Este bloco de localização lida o processamento atual do PHP apontando o Nginx para o arquivo de configuração fastcgi-php.conf e o arquivo php7.2-fpm.sock que declara qual soquete está associado ao php-fpm.
      • location ~ /.ht — O último bloco de localização lida com os arquivos .htaccess, que o Nginx não processa. Ao adicionar a diretriz deny all, se algum arquivo .htaccess encontrar seu caminho para a root do documento ele não será apresentado aos visitantes.

      Após adicionar este conteúdo, salve e feche o arquivo. Habilite seu novo bloco de servidor criando um link simbólico do seu novo arquivo de configuração de bloco de servidor (no diretório /etc/nginx/sites-available/) para o diretório /etc/nginx/sites-enabled/:

      • sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/

      Então, desvincule o arquivo de configuração padrão do diretório /sites-enabled/:

      • sudo unlink /etc/nginx/sites-enabled/default

      Nota: Se for necessário restaurar a configuração padrão, recrie o link simbólico, desta forma:

      • sudo ln -s /etc/nginx/sites-available/default /etc/nginx/sites-enabled/

      Teste seu novo arquivo de configuração para erros de sintaxe digitando:

      Se algum erro for reportado, volte e verifique novamente seu arquivo antes de continuar.

      Quando estiver pronto, recarregue o Nginx para fazer as alterações necessárias:

      • sudo systemctl reload nginx

      Isto conclui a instalação e configuração da sua pilha LEMP. No entanto, é prudente confirmar que todos os componentes podem se comunicar uns com os outros.

      Passo 4 — Como criar um arquivo PHP para testar a configuração

      Sua pilha LEMP agora deve estar configurada completamente. Teste ela para validar que o Nginx pode passar corretamente os arquivos .php para o processador PHP.

      Para fazer isso, utilize seu editor de texto para criar um arquivo de teste PHP chamado info.php na sua root do documento:

      • sudo nano /var/www/html/info.php

      Digite as linhas a seguir para o novo arquivo. Este é um código PHP válido que irá retornar informações sobre seu servidor:

      /var/www/html/info.php

      <?php
      phpinfo();
      

      Quando você terminar, salve e feche o arquivo.

      Agora, visite esta página no seu navegador Web visitando o nome de domínio do seu servidor ou endereço IP público seguido por /info.php:

      http://your_server_domain_or_IP/info.php
      

      Você deve ver uma página Web que foi gerada pelo PHP com informações sobre seu servidor:

      PHP page info

      Se você ver uma página que se pareça com essa, o processamento PHP com o Nginx foi configurado com sucesso.

      Após verificar que o Nginx renderiza a página corretamente, é melhor remover o arquivo que você criou uma vez que ele pode de fato dar a usuários não autorizados algumas dicas sobre sua configuração que podem ajudá-los a tentar invadir. Você sempre pode gerar novamente este arquivo se precisar dele mais tarde.

      Agora, remova o arquivo digitando:

      • sudo rm /var/www/html/info.php

      Com isso, você agora tem uma pilha LEMP totalmente configurada e funcionando no seu servidor Ubuntu 18.04.

      Conclusão

      Uma pilha LEMP é uma plataforma poderosa que permitirá que você configure e apresente quase qualquer site ou aplicativo do seu servidor.

      Há um número de passos que você pode tomar a partir daqui. Por exemplo, certifique-se de que as conexões para seu servidor estejam seguras. Para isso, você pode proteger sua instalação Nginx com o Let’s Encrypt. Ao seguir este guia, você receberá um certificado TLS/SSL gratuito para seu servidor, permitindo que apresente conteúdo sobre o HTTPS.



      Source link

      Como instalar o Nginx no Ubuntu 18.04 [Início rápido]


      Introdução

      O Nginx é um dos servidores Web mais populares no mundo e é responsável por hospedar alguns dos sites de maior tráfego na Internet. Ele é mais amigável do que o Apache em termos de recursos na maioria dos casos e pode ser usado como um servidor Web ou como proxy reverso.

      Neste guia, explicamos como instalar o Nginx no seu servidor Ubuntu 18.04. Para uma versão mais detalhada deste tutorial, consulte Como Instalar o Nginx no Ubuntu 18.04.

      Pré-requisitos

      Antes de iniciar este guia, você deve ter o seguinte:

      • Um servidor Ubuntu 18.04 e um usuário regular não-root com privilégios sudo. Além disso, você precisará habilitar um firewall básico para bloquear portas não essenciais. Você pode aprender como configurar uma conta de usuário comum e configurar um firewall seguindo nosso guia de configuração inicial de servidor para o Ubuntu 18.04.

      Quando tiver uma conta disponível, logue com seu usuário não raiz para começar.

      Passo 1 – Como instalar o Nginx

      Uma vez que o Nginx está disponível nos repositórios padrão do Ubuntu, instale ele utilizando o sistema de empacotamento apt.

      Atualize seu índice de pacotes local:

      Instale o Nginx:

      Passo 2 — Como ajustar o Firewall

      Se seguiu o tutorial pré-requisito de configuração do servidor, então você tem o firewall UFW ativado. Verifique os perfis de aplicativo ufw disponíveis com o seguinte comando:

      Output

      Available applications: Nginx Full Nginx HTTP Nginx HTTPS OpenSSH

      Vamos habilitar o perfil mais restritivo que ainda permitirá o tráfego que você configurou, permitindo o tráfego na porta 80:

      • sudo ufw allow 'Nginx HTTP'

      Verifique a mudança:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere Nginx HTTP ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) Nginx HTTP (v6) ALLOW Anywhere (v6)

      Passo 3 — Como verificar seu Servidor Web

      Verifique com o sistema init systemd para garantir que o serviço esteja funcionando digitando:

      Output

      ● nginx.service - A high performance web server and a reverse proxy server Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2018-04-20 16:08:19 UTC; 3 days ago Docs: man:nginx(8) Main PID: 2369 (nginx) Tasks: 2 (limit: 1153) CGroup: /system.slice/nginx.service ├─2369 nginx: master process /usr/sbin/nginx -g daemon on; master_process on; └─2380 nginx: worker process

      Acesse a página inicial padrão do Nginx para confirmar que o software está funcionando corretamente através do seu endereço IP:

      http://your_server_ip
      

      Você deve ver a página inicial padrão do Nginx:

      Nginx default page

      Passo 4 — Como configurar os blocos de servidor (recomendado)

      Ao usar o servidor Web Apache, é possível usar os server blocks (similares aos hosts virtuais no Apache) para encapsular detalhes de configuração e hospedar mais de um domínio de um único servidor. Vamos configurar um domínio chamado example.com, mas você deve substituí-lo por seu próprio nome de domínio. Para aprender mais sobre configuração de um nome de domínio com o DigitalOcean, veja nossa introdução ao DNS DigitalOcean.

      Crie o diretório para example.com, usando a flag -p para criar quaisquer diretórios parentais necessários:

      • sudo mkdir -p /var/www/example.com/html

      Atribua a posse do diretório:

      • sudo chown -R $USER:$USER /var/www/example.com/html

      As permissões das suas raízes Web devem estar corretas se ainda não tiver modificado seu valor umask, mas você pode certificar-se digitando:

      • sudo chmod -R 755 /var/www/example.com

      Crie uma página de amostra index.html utilizando o nano ou seu editor favorito:

      • nano /var/www/example.com/html/index.html

      Dentro, adicione a seguinte amostra HTML:

      /var/www/example.com/html/index.html

      <html>
          <head>
              <title>Welcome to Example.com!</title>
          </head>
          <body>
              <h1>Success!  The example.com server block is working!</h1>
          </body>
      </html>
      

      Salve e feche o arquivo quando terminar.

      Faça um novo bloco de servidor em /etc/nginx/sites-available/example.com:

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

      Cole no seguinte bloco de configuração, atualizado para nosso novo diretório e nome de domínio:

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

      server {
              listen 80;
              listen [::]:80;
      
              root /var/www/example.com/html;
              index index.html index.htm index.nginx-debian.html;
      
              server_name example.com www.example.com;
      
              location / {
                      try_files $uri $uri/ =404;
              }
      }
      

      Salve e feche o arquivo quando terminar.

      Habilite o arquivo criando um link dele para o diretório sites-enabled:

      • sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/

      Agora, dois blocos de servidor estão habilitados e configurados para responder a pedidos baseados nas diretrizes listen e server_name:

      • example.com: Responderá aos pedidos para example.com e www.example.com.
      • default: Responderá a quaisquer pedidos na porta 80 que não correspondam aos outros dois blocos.

      Para evitar um possível problema de memória de hash que possa surgir ao adicionar nomes adicionais de servidor, é necessário ajustar um valor único no arquivo /etc/nginx/nginx.conf. Abra o arquivo:

      • sudo nano /etc/nginx/nginx.conf

      Encontre a diretriz server_names_hash_bucket_size e remova o símbolo # para remover a marca de comentário da linha:

      /etc/nginx/nginx.conf

      ...
      http {
          ...
          server_names_hash_bucket_size 64;
          ...
      }
      ...
      

      Teste para conferir se há erros de sintaxe:

      Reinicie o Nginx para habilitar suas alterações:

      • sudo systemctl restart nginx

      O Nginx agora deve estar atendendo seu nome de domínio. É possível testar isso ao navegar para http://example.com, onde você deve ver algo parecido com isso:

      Nginx first server block

      Conclusão

      Agora que tem seu servidor Web instalado, você tem muitas opções para o tipo de conteúdo a oferecer e as tecnologias que quiser usar para criar uma experiência mais rica.

      Se quiser construir uma pilha de aplicativo mais completa, verifique este artigo sobre como configurar uma pilha LEMP no Ubuntu 18.04.



      Source link

      How To Serve Flask Applications with Gunicorn and Nginx on Ubuntu 18.04


      Introdução

      Neste guia, você construirá um aplicativo Python usando o microframework Flask no Ubuntu 18.04. A maior parte deste artigo será sobre como configurar o servidor do aplicativo Gunicorn, como iniciar o aplicativo e configurar o Nginx para atuar como um proxy reverso no front-end.

      Pré-requisitos

      Antes de iniciar este guia, você deve ter:

      • Um servidor com o Ubuntu 18.04 instalado e um usuário não raiz com privilégios sudo. Siga nosso guia de configuração inicial do servidor para orientação.
      • O Nginx instalado, seguindo os Passos 1 e 2 de Como Instalar o Nginx no Ubuntu 18.04.
      • Um nome de domínio configurado para apontar para o seu servidor. Você pode comprar um no Namecheap ou obter um de graça no Freenom. Você pode aprender como apontar domínios para o DigitalOcean seguindo a relevante documentação para domínios e DNS. Certifique-se de criar os seguintes registros DNS:

        • Um registro com o your_domain <^>apontando para o endereço IP público do seu servidor.
        • Um registro A com www.your_domain apontando para o endereço IP público do seu servidor.
      • Familiarize-se com a especificação do WSGI, que o servidor do Gunicorn usará para se comunicar com seu aplicativo Flask. Esta discussãoaborda mais detalhadamente o WSGI.

      Passo 1 — Instalando os componentes dos repositórios do Ubuntu

      Nosso primeiro passo será instalar todas as partes que precisamos dos repositórios do Ubuntu. Isso inclui o pip, o gerenciador de pacotes Python que irá gerenciar nossos componentes Python. Também vamos obter os arquivos de desenvolvimento do Python necessários para construir alguns dos componentes do Gunicorn.

      Primeiramente, vamos atualizar o índice local de pacotes e instalar os pacotes que irão nos permitir construir nosso ambiente Python. Estes incluem o python3-pip, junto com alguns outros pacotes e ferramentas de desenvolvimento necessários para um ambiente de programação robusto:

      • sudo apt update
      • sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools

      Com esses pacotes instalados, vamos seguir em frente para criar um ambiente virtual para nosso projeto.

      Passo 2 — Criando um Ambiente Virtual em Python

      Em seguida, vamos configurar um ambiente virtual para isolar nosso aplicativo Flask dos outros arquivos Python no sistema.

      Inicie instalando o pacote python3-venv, que instalará o módulo venv:

      • sudo apt install python3-venv

      Em seguida, vamos fazer um diretório pai para nosso projeto Flask. Acesse o diretório após criá-lo:

      • mkdir ~/myproject
      • cd ~/myproject

      Crie um ambiente virtual para armazenar os requisitos Python do projeto Flask digitando:

      • python3.6 -m venv myprojectenv

      Isso instalará uma cópia local do Python e do pip para um diretório chamado myprojectenv dentro do diretório do seu projeto.

      Antes de instalar aplicativos no ambiente virtual, você precisa ativá-lo. Faça isso digitando:

      • source myprojectenv/bin/activate

      Seu prompt mudará para indicar que você agora está operando no ambiente virtual. Ele se parecerá com isso: (myprojectenv)user@host:~/myproject$.

      Passo 3 — Configurando um aplicativo Flask

      Agora que você está no seu ambiente virtual, instale o Flask e o Gunicorn e comece a projetar seu aplicativo.

      Primeiramente, vamos instalar o wheel com a instância local do pip para garantir que nossos pacotes sejam instalados mesmo se estiverem faltando arquivos wheel:

      Nota: Independentemente da versão do Python que você estiver usando, quando o ambiente virtual for ativado, você deve usar o comando pip (não o pip3).

      Em seguida, vamos instalar o Flask e o Gunicorn:

      • pip install gunicorn flask

      Criando um app de exemplo

      Agora que você tem o Flask disponível, você pode criar um aplicativo simples. O Flask é um microframework. Ele não inclui muitas das ferramentas que os frameworks mais completos talvez tenham. Ele existe, principalmente, como um módulo que você pode importar para seus projetos para ajudá-lo na inicialização de um aplicativo Web.

      Embora seu aplicativo possa ser mais complexo, vamos criar nosso app Flask em um único arquivo, chamado myproject.py:<^>

      • nano ~/myproject/myproject.py

      O código do aplicativo ficará neste arquivo. Ele importará o Flask e instanciará um objeto Flask. Você pode usar isto para definir as funções que devem ser executadas quando uma rota específica for solicitada:

      ~/myproject/myproject.py

      from flask import Flask
      app = Flask(__name__)
      
      @app.route("/")
      def hello():
          return "<h1 style='color:blue'>Hello There!</h1>"
      
      if __name__ == "__main__":
          app.run(host='0.0.0.0')
      

      Isso define basicamente qual conteúdo apresentar quando o domínio raiz for acessado. Salve e feche o arquivo quando você terminar.

      Se você seguiu o guia de configuração inicial do servidor, você deverá ter um firewall UFW ativado. Para testar o aplicativo, será necessário permitir o acesso à porta 5000:

      Agora é possível testar seu app Flask digitando:

      Você verá um resultado como o seguinte, incluindo um aviso útil lembrando para não usar essa configuração de servidor na produção:

      Output

      * Serving Flask app "myproject" (lazy loading) * Environment: production WARNING: Do not use the development server in a production environment. Use a production WSGI server instead. * Debug mode: off * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

      Visite o endereço IP do seu servidor seguido de :5000 no seu navegador Web:

      http://your_server_ip:5000
      

      Você deve ver algo como isto:

      Flask sample app

      Quando terminar, tecle CTRL-C na janela do seu terminal para parar o servidor de desenvolvimento Flask.

      Criando o ponto de entrada da WSGI

      Em seguida, vamos criar um arquivo que servirá como o ponto de entrada para nosso aplicativo. Isso dirá ao nosso servidor do Gunicorn como interagir com o aplicativo.

      Vamos chamar o arquivo de wsgi.py:

      Neste arquivo, vamos importar a instância Flask do nosso aplicativo e então executá-lo:

      ~/myproject/wsgi.py

      from myproject import app
      
      if __name__ == "__main__":
          app.run()
      

      Salve e feche o arquivo quando você terminar.

      Passo 4 — Configurando o Gunicorn

      Seu aplicativo agora está gravado com um ponto de entrada estabelecido. Podemos agora seguir em frente para configurar o Gunicorn.

      Antes de continuar, devemos verificar se o Gunicorn pode atender o aplicativo corretamente.

      Podemos fazer essa verificação simplesmente passando o nome do nosso ponto de entrada para o Gunicorn. Criamos esse ponto de entrada como o nome do módulo (menos a extensão .py) mais o nome do objeto callable dentro do aplicativo. No nosso caso, trata-se do wsgi:app.

      Também vamos especificar a interface e a porta a vincular, de modo que o aplicativo seja iniciado em uma interface disponível publicamente:

      • cd ~/myproject
      • gunicorn --bind 0.0.0.0:5000 wsgi:app

      Deverá ver um resultado como o seguinte:

      Output

      [2018-07-13 19:35:13 +0000] [28217] [INFO] Starting gunicorn 19.9.0 [2018-07-13 19:35:13 +0000] [28217] [INFO] Listening at: http://0.0.0.0:5000 (28217) [2018-07-13 19:35:13 +0000] [28217] [INFO] Using worker: sync [2018-07-13 19:35:13 +0000] [28220] [INFO] Booting worker with pid: 28220

      Visite o endereço IP do seu servidor com :5000 anexado ao final no seu navegador Web novamente:

      http://your_server_ip:5000
      

      Você deve ver o resultado do seu aplicativo:

      Flask sample app

      Quando você tiver confirmado que ele está funcionando corretamente, pressione CTRL-C na janela do seu terminal.

      Acabamos agora o nosso ambiente virtual, para que possamos desativá-lo:

      Agora, qualquer comando Python voltará a usar o ambiente do sistema Python.

      Em seguida, vamos criar o arquivo da unidade de serviço systemd. Criar um arquivo de unidade systemd permitirá que o sistema init do Ubuntu inicie automaticamente o Gunicorn e atenda o aplicativo Flask sempre que o servidor inicializar.

      Crie um arquivo de unidade que termine com .service dentro do diretório /etc/systemd/system para começar:

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

      Ali, vamos começar com a seção [Unit], que é usada para especificar os metadados e dependências. Vamos colocar uma descrição do nosso serviço aqui e dizer ao sistema init para iniciar isso somente após o objetivo da rede ter sido alcançado:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=Gunicorn instance to serve myproject
      After=network.target
      

      Em seguida, vamos abrir a seção [Service]. Isso especificará o usuário e o grupo sob o qual que queremos que o processo seja executado. Vamos dar à nossa conta de usuário regular a propriedade sobre o processo, uma vez que ela possui todos os arquivos relevantes. Vamos também dar a propriedade sobre o grupo para o grupo www-data, de modo que o Nginx possa se comunicar facilmente com os processos do Gunicorn. Lembre-se de substituir o nome de usuário abaixo pelo seu nome de usuário:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=Gunicorn instance to serve myproject
      After=network.target
      
      [Service]
      User=sammy
      Group=www-data
      

      Em seguida, vamos mapear o diretório de trabalho e definir a variável de ambiente PATH para que o sistema init saiba que os executáveis do processo estão localizados dentro do nosso ambiente virtual. Vamos também especificar o comando para iniciar o serviço. Este comando fará o seguinte:

      • Iniciar três processos de trabalho (embora deva ajustar isso conforme necessário)
      • Criar e vincular a um arquivo de socket Unix, myproject<^>.sock, dentro de nosso diretório de projeto. Vamos definir um valor de umask de 007 para que o arquivo socket seja criado dando acesso ao proprietário e ao grupo, ao mesmo tempo que restringe outros acessos
      • Especificar o nome do arquivo de ponto de entrada da WSGI, junto com o objeto callable do Python dentro daquele arquivo (wsgi:app)

      O systemd exige que seja dado o caminho completo para o executável do Gunicorn, que está instalado dentro do nosso ambiente virtual.

      Lembre-se de substituir o nome de usuário e os caminhos do projeto por seus próprios dados:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=Gunicorn instance to serve myproject
      After=network.target
      
      [Service]
      User=sammy
      Group=www-data
      WorkingDirectory=/home/sammy/myproject
      Environment="PATH=/home/sammy/myproject/myprojectenv/bin"
      ExecStart=/home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app
      

      Finalmente, vamos adicionar uma seção [Install]. Isso dirá ao systemd ao que vincular este serviço se nós o habilitarmos para iniciar na inicialização. Queremos que este serviço comece quando o sistema regular de vários usuários estiver funcionando:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=Gunicorn instance to serve myproject
      After=network.target
      
      [Service]
      User=sammy
      Group=www-data
      WorkingDirectory=/home/sammy/myproject
      Environment="PATH=/home/sammy/myproject/myprojectenv/bin"
      ExecStart=/home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app
      
      [Install]
      WantedBy=multi-user.target
      

      Com isso, nosso arquivo de serviço systemd está completo. Salve e feche-o agora.

      Podemos agora iniciar o serviço Gunicorn que criamos e habilitá-lo para que ele seja iniciado na inicialização:

      • sudo systemctl start myproject
      • sudo systemctl enable myproject

      Vamos verificar o status:

      • sudo systemctl status myproject

      Você deve ver um resultado como este:

      Output

      ● myproject.service - Gunicorn instance to serve myproject Loaded: loaded (/etc/systemd/system/myproject.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2018-07-13 14:28:39 UTC; 46s ago Main PID: 28232 (gunicorn) Tasks: 4 (limit: 1153) CGroup: /system.slice/myproject.service ├─28232 /home/sammy/myproject/myprojectenv/bin/python3.6 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 ├─28250 /home/sammy/myproject/myprojectenv/bin/python3.6 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 ├─28251 /home/sammy/myproject/myprojectenv/bin/python3.6 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 └─28252 /home/sammy/myproject/myprojectenv/bin/python3.6 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007

      Se encontrar erros, certifique-se de resolvê-los antes de continuar com o tutorial.

      Passo 5 — Configurando o Nginx para solicitações de proxy

      Nosso servidor do aplicativo Gunicorn deve estar funcionando agora, esperando pedidos no arquivo de socket no diretório do projeto. Vamos agora configurar o Nginx para passar pedidos Web para aquele socket, fazendo algumas pequenas adições ao seu arquivo de configuração.

      Comece criando um novo arquivo de configuração do bloco do servidor no diretório sites-available do Nginx. Vamos chamá-lo de myproject para mantê-lo alinhado com o resto do guia:

      • sudo nano /etc/nginx/sites-available/myproject

      Abra um bloco de servidor e diga ao Nginx para escutar na porta padrão 80. Vamos também dizer a ele para usar este bloco para pedidos para o nome de domínio do nosso servidor:

      /etc/nginx/sites-available/myproject

      server {
          listen 80;
          server_name your_domain www.your_domain;
      }
      

      Em seguida, vamos adicionar um bloco de localização que corresponda a cada pedido. Dentro deste bloco, vamos incluir o arquivo proxy_params que especifica alguns parâmetros gerais de proxy que precisam ser configurados. Vamos então passar os pedidos para o socket que definimos usando a diretriz proxy_pass:

      /etc/nginx/sites-available/myproject

      server {
          listen 80;
          server_name your_domain www.your_domain;
      
          location / {
              include proxy_params;
              proxy_pass http://unix:/home/sammy/myproject/myproject.sock;
          }
      }
      

      Salve e feche o arquivo quando terminar.

      Para habilitar a configuração do bloco do servidor Nginx que acabou de criar, vincule o arquivo ao diretório sites-enabled:

      • sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

      Com o arquivo naquele diretório, você pode testar quanto a erros de sintaxe:

      Se retornar sem indicar quaisquer problemas, reinicie o processo Nginx para ler a nova configuração:

      • sudo systemctl restart nginx

      Finalmente, vamos ajustar o firewall novamente. Já não precisamos de acesso através da porta 5000, então podemos remover essa regra. Podemos então conceder acesso total ao servidor Nginx:

      • sudo ufw delete allow 5000
      • sudo ufw allow 'Nginx Full'

      Agora, você consegue navegar até o nome de domínio do seu servidor no seu navegador Web:

      http://your_domain
      

      Você deve ver o resultado do seu aplicativo:

      Flask sample app

      Caso encontre quaisquer erros, tente verificar o seguinte:

      • sudo less /var/log/nginx/error.log: verifica os registros de erros do Nginx.
      • sudo less /var/log/nginx/access.log: verifica os registros de acesso do Nginx.
      • sudo journalctl -u nginx: verifica os registros de processo do Nginx.
      • sudo journalctl -u myproject: verifica os registros do Gunicorn do seu app Flask.

      Passo 6 — Protegendo o aplicativo

      Para garantir que o tráfego para seu servidor permaneça protegido, vamos obter um certificado SSL para seu domínio. Há várias maneiras de fazer isso, incluindo a obtenção de um certificado gratuito do Let’s Encrypt, gerando um certificado autoassinado ou comprando algum de outro provedor e configurando o Nginx para usá-lo, seguindo os Passos 2 a 6 de Como criar um certificado SSL autoassinado para o Nginx no Ubuntu 18.04. Vamos escolher a opção um por questão de conveniência.

      Primeiramente, adicione o repositório de software Ubuntu do Certbot:

      • sudo add-apt-repository ppa:certbot/certbot

      Aperte ENTER para aceitar.

      Instale o pacote Nginx do Certbot com o apt:

      • sudo apt install python-certbot-nginx

      O Certbot oferece várias maneiras de obter certificados SSL através de plug-ins. O plug-in Nginx cuidará da reconfiguração do Nginx e recarregará a configuração sempre que necessário. Para usar este plug-in, digite o seguinte:

      • sudo certbot --nginx -d your_domain -d www.your_domain

      Esse comando executa o certbot com o plug-in --nginx, usando -d para especificar os nomes para os quais desejamos um certificado válido.

      Se essa é a primeira vez que você executa o certbot, você será solicitado a informar um endereço de e-mail e concordar com os termos de serviço. Após fazer isso, o certbot se comunicará com o servidor da Let’s Encrypt, executando posteriormente um desafio para verificar se você controla o domínio para o qual está solicitando um certificado.

      Se tudo correr bem, o certbot perguntará como você quer definir suas configurações de HTTPS:

      Output

      Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access. ------------------------------------------------------------------------------- 1: No redirect - Make no further changes to the webserver configuration. 2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for new sites, or if you're confident your site works on HTTPS. You can undo this change by editing your web server's configuration. ------------------------------------------------------------------------------- Select the appropriate number [1-2] then [enter] (press 'c' to cancel):

      Select your choice then hit ​​​ENTER​​​​​. A configuração será atualizada e o Nginx recarregará para aplicar as novas configurações. O certbot será encerrado com uma mensagem informando que o processo foi concluído e onde os certificados estão armazenados:

      Output

      IMPORTANT NOTES: - Congratulations! Your certificate and chain have been saved at: /etc/letsencrypt/live/your_domain/fullchain.pem Your key file has been saved at: /etc/letsencrypt/live/your_domain/privkey.pem Your cert will expire on 2018-07-23. To obtain a new or tweaked version of this certificate in the future, simply run certbot again with the "certonly" option. To non-interactively renew *all* of your certificates, run "certbot renew" - Your account credentials have been saved in your Certbot configuration directory at /etc/letsencrypt. You should make a secure backup of this folder now. This configuration directory will also contain certificates and private keys obtained by Certbot so making regular backups of this folder is ideal. - If you like Certbot, please consider supporting our work by: Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate Donating to EFF: https://eff.org/donate-le

      Se seguiu as instruções de instalação do Nginx nos pré-requisitos, a permissão do perfil HTTP redundante não é mais necessária:

      • sudo ufw delete allow 'Nginx HTTP'

      Para verificar a configuração, navegue novamente para seu domínio, usando https://:

      https://your_domain
      

      Você deve ver novamente o resultado do seu aplicativo, junto com o indicador de segurança do seu navegador, o qual deve indicar que o site está protegido.

      Conclusão

      Neste guia, você criou e protegeu um aplicativo Flask simples em um ambiente virtual Python. Você criou um ponto de entrada da WSGI para que qualquer servidor de aplicativo compatível com a WSGI possa interagir com ela, e então configurou o servidor de app Gunicorn para fornecer essa função. Depois, criou um arquivo de serviço systemd para iniciar automaticamente o servidor do aplicativo na inicialização. Você também criou um bloco de servidor Nginx que passa o tráfego Web do cliente para o servidor do aplicativo - retransmitindo pedidos externos - e protegeu o tráfego para seu servidor com o Let’s Encrypt.

      O Flask é um framework muito simples - mas extremamente flexível, destinado a fornecer funcionalidade a seus aplicativos sem ser restritivo demais em termos de estrutura e design. Você pode usar a pilha geral descrita neste guia para atender os aplicativos flask que projetar.



      Source link