in

Como instalar um Nginx, MySQL e PHP (FEMP) Stack no FreeBSD 10.1

Nginx, MySQL e PHP podem ser combinados facilmente como uma solução poderosa para servir conteúdo dinâmico na web.

Nginx, MySQL e PHP podem ser combinados facilmente como uma solução poderosa para servir conteúdo dinâmico na web. Esses três softwares podem ser instalados e configurados em uma máquina FreeBSD para criar o que é conhecido como uma FEMP.

Neste guia, vamos demonstrar como instalar uma pilha FEMP em um servidor FreeBSD 10.1. Estaremos instalando o software usando pkg para podermos atualizar mais rapidamente. Esses pacotes fornecem padrões razoáveis que funcionam bem para a maioria dos servidores.

Instale os componentes

Para começar, vamos instalar todo o software que precisamos usando o sistema de pacotes FreeBSD. O comando “install” atualizará nossa cópia local dos pacotes disponíveis e, em seguida, instalará os pacotes que solicitamos:

sudo pkg install nginx mysql56-server php56 php56-mysql

Isso irá baixar e instalar um servidor web Nginx para servir nosso conteúdo, um servidor de banco de dados MySQL usado para armazenar informações e uma linguagem para processar conteúdo dinâmico PHP.

Uma vez que a instalação esteja completa, certifique-se de executar o comando rehash se você estiver executando o shell padrão tcsh. Isso torna o shell ciente dos novos aplicativos que você instalou:

rehash

Quando terminar, você pode avançar para começar a ativar e configurar seus componentes.

Ativando Serviços para uma FEMP

Acima, baixamos três serviços separados que precisarão ser executados no nosso servidor.

Para que possamos inciar estes serviços, precisamos dizer ao FreeBSD que queremos habilitá-los. Isso nos permitirá lidar com eles como serviços em vez de aplicativos únicos e também configurará o FreeBSD para iniciá-los automaticamente na inicialização.

Primeiro, precisamos saber o parâmetro rc correto a definir para cada serviço. Os scripts de serviço, que estão localizados no diretório /usr/local/etc/rc.d definem o parâmetro que deve ser usado para habilitar cada servidor usando a variável rcvar. Podemos ver como o rcvar de cada serviço está configurado ao digitar:

grep rcvar /usr/local/etc/rc.d/*

Você deve obter uma lista como esta:

/usr/local/etc/rc.d/avahi-daemon:rcvar=avahi_daemon_enable
/usr/local/etc/rc.d/avahi-dnsconfd:rcvar=avahi_dnsconfd_enable
/usr/local/etc/rc.d/dbus:rcvar=dbus_enable
/usr/local/etc/rc.d/mysql-server:rcvar=mysql_enable
/usr/local/etc/rc.d/nginx:rcvar=nginx_enable
/usr/local/etc/rc.d/php-fpm:rcvar=php_fpm_enable
/usr/local/etc/rc.d/rsyncd:rcvar=rsyncd_enable

Como você pode ver, isso nos permite produzir facilmente o parâmetro que precisamos definir para cada um de nossos serviços. O nome do script em si (o último componente do caminho até o último da lista) é notável, pois nos informa o nome real que o FreeBSD usa para o serviço.

Para habilitar esses serviços, editaremos o arquivo /etc/rc.conf com privilégios sudo:

sudo vi /etc/rc.conf

No arquivo, vamos adicionar uma linha para cada um dos serviços que desejamos começar. Podemos usar o parâmetro rcvar que descobrimos para cada serviço e configurá-lo para “YES” para habilitar cada um:

mysql_enable="YES"
nginx_enable="YES"
php_fpm_enable="YES"

Salve e feche o arquivo quando terminar.

Configurando o PHP

Em seguida, vamos configurar o nosso serviço PHP-FPM, que será responsável pelo processamento de pedidos PHP enviados pelo nosso servidor web.

Para começar, mude para o diretório /usr/local/etc, onde os arquivos de configuração para nossos programas opcionais são armazenados:

cd /usr/local/etc

Existem vários arquivos de configuração do PHP neste diretório que queremos modificar. Começaremos com o próprio arquivo de configuração PHP-FPM. Abra ele com privilégios sudo:

sudo vi php-fpm.conf

No arquivo, queremos ajustar algumas opções diferentes. Primeiro, queremos configurar o PHP-FPM para usar um soquete Unix em vez de uma porta de rede para comunicação. Isto é mais seguro para os serviços que se comunicam dentro de um único servidor.

Encontre a linha que se parece com esta:

listen = 127.0.0.1:9000

Altere isso para usar um soquete dentro do diretório /var/run:

listen = /var/run/php-fpm.sock

Em seguida, configuraremos o conjunto proprietário, grupo e permissões do soquete que será criado. Existe um grupo comentado de opções que lida com esta configuração que se parece com isto:

;listen.owner = www
;listen.group = www
;listen.mode = 0660

Ative estes recursos removendo o marcador de comentário no início:

listen.owner = www
listen.group = www
listen.mode = 0660

Salve e feche o arquivo quando terminar.

Em seguida, precisamos criar um arquivo php.ini que configure o comportamento geral do PHP. Foram incluídos dois exemplos de arquivos que podemos escolher para copiar para o arquivo php.ini que o PHP lê.

O arquivo de produção do php.ini é quase o que precisamos, então vamos usar esse. Copie a versão de produção para o arquivo padrão, assim o PHP poderá verificar:

sudo cp php.ini-production php.ini

Abra o arquivo para edição com privilégios sudo:

sudo vi php.ini

No arquivo, precisamos encontrar uma seção chamada cgi.fix_pathinfo. Ela está comentada e configurada para “1” por padrão. Precisamos descomentar isso e configurá-la para “0“. Isso impedirá o PHP de tentar executar partes do caminho se o arquivo que foi passado no processo não for encontrado. Isso pode ser usado por usuários mal-intencionados para executar código arbitrário caso não impeça esse comportamento.

Descomente a linha cig.fix_pathinfo e defina-a como “0”:

cgi.fix_pathinfo=0

Salve e feche o arquivo quando terminar.

Agora que temos o PHP-FPM completamente configurado, podemos iniciar o serviço digitando:

sudo service php-fpm start

Agora vamos avançar e configurar o MySQL.

Configurando o MySQL

Para começar a configurar o MySQL, precisamos iniciar o serviço MySQL:

sudo service mysql-server start

Na primeira vez que você executa este comando, ele criará a estrutura de diretório necessária no sistema de arquivos e instalará os arquivos de banco de dados necessários. Em seguida, iniciará o processo do servidor MySQL.

Após o início do serviço, precisamos garantir a instalação. Isso pode ser feito através de um script chamado mysql_secure_installation. Execute isso com privilégios sudo para bloquear alguns padrões inseguros:

sudo mysql_secure_installation
. . .

Enter current password for root (enter for none):

O script começará pedindo a senha atual para a conta root do MySQL. Uma vez que ainda não definimos uma senha para este usuário, podemos pressionar “ENTER” para ignorar este prompt.

Set root password? [Y/n]

Em seguida, ele irá perguntar se você gostaria de configurar a senha da conta principal do MySQL. Pressione “ENTER” para aceitar esta sugestão. Escolha e confirme uma senha administrativa.

O script continuará com sugestões adicionais que ajudarão a reverter algumas condições inseguras na instalação padrão do MySQL. Basta pressionar “ENTER” através de todos esses prompts para completar todas as ações sugeridas.

Podemos reiniciar o serviço MySQL para garantir que nossa instância implemente imediatamente as mudanças de segurança:

sudo service mysql-server restart

Nosso MySQL agora está funcionando como nós queremos, agora podemos seguir em frente.

Configurando o NGINX

Nossa próxima tarefa é configurar o Nginx. Para começar, precisamos iniciar o servidor web:

Agora, podemos começar a configurar nosso servidor web indo para o diretório raiz do nginx:

cd /usr/local/etc/nginx

Aqui, precisamos abrir o arquivo de configuração principal do Nginx com privilégios sudo:

sudo vi nginx.conf

No arquivo, podemos começar a fazer mudanças para que nossa instância Nginx possa trabalhar com nossos outros componentes.

Para começar, descomente e modifique a diretriz do usuário na parte superior do arquivo. Precisamos que o servidor web funcione como o usuário www, já que é isso que a nossa instância PHP-FPM está procurando:

Também devemos definir os work_process no número de CPUs ou núcleos que seu sistema possui. (Para descobrir quantas CPUs seu servidor possui, digite sysctl hw.ncpu na linha de comando):

worker_processes 2;

Em seguida, vamos definir a localização do relatório de erro usando a diretiva error_log. Iremos usar o diretório /var/log/nginx/error.log para o nível de informações:

error_log /var/log/nginx/error.log info;

No bloco http, também configuraremos um registro de acesso. Isso será localizado em /var/log/nginx/access.log:

access_log /var/log/nginx/access.log;

No bloco do servidor, precisamos modificar a diretiva server_name para usar o nome do domínio ou o endereço IP do nosso servidor. Nós podemos fazer o nosso servidor responder ao hostnames de www também, adicionando isso depois do domínio principal:

server {
    listen          80;
    server_name     example.com www.example.com;

    . . .

Configure as diretrizes root index no bloco do servidor. A nossa raiz de documentos será / usr / local / www / nginx e nossa diretriz de índice deve tentar fornecer arquivos index.php antes de retornar nos arquivos index.html ou index.htm.

Como definimos essas diretivas no contexto do servidor, não as precisamos dentro do bloco location /. Neste bloco, configuraremos uma diretiva try_files para tentar atender solicitações de usuários como um arquivo e, em seguida, um diretório antes de cair com um erro 404:

server {

    . . .

    root /usr/local/www/nginx;
    index index.php index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }

    . . .

Finalmente, precisamos configurar um bloco de localização que manipule arquivos PHP. Este bloco irá corresponder a qualquer pedido que termine em .php. Ele só processará os próprios arquivos, lançando um erro 404 se o arquivo não puder ser encontrado.

Usaremos o soquete que configuramos no arquivo php-fpm.conf anteriormente. Também vamos configurar algumas outras opções de proxy FastCGI, em parte através da leitura em parâmetros do arquivo fastcgi_params. Precisamos definir explicitamente o parâmetro SCRIPT_FILENAME para que o PHP conheça os arquivos a serem executados:

server {

    . . .

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/var/run/php-fpm.sock;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $request_filename;
        include fastcgi_params;
    }

Com comentários removidos, o arquivo deve ser semelhante a este:

user  www;
worker_processes  2;
error_log /var/log/nginx/error.log info;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    access_log /var/log/nginx/access.log;

    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       80;
        server_name  example.com www.example.com;
        root /usr/local/www/nginx;
        index index.php index.html index.htm;

        location / {
            try_files $uri $uri/ =404;
        }

        error_page      500 502 503 504  /50x.html;
        location = /50x.html {
            root /usr/local/www/nginx-dist;
        }

        location ~ \.php$ {
                try_files $uri =404;
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_pass unix:/var/run/php-fpm.sock;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $request_filename;
                include fastcgi_params;
        }
    }
}

Salve e feche o arquivo quando terminar.

Agora precisamos criar o diretório de log e os arquivos que referenciamos em nosso arquivo. Primeiro, crie o diretório /var/log/nginx:

sudo mkdir -p /var/log/nginx

Em seguida, podemos criar os arquivos de log vazios:

sudo touch /var/log/nginx/access.log
sudo touch /var/log/nginx/error.log

Agora, estamos prontos para configurar a raiz do nosso documento. Nós configuramos a nossa raiz para ser /usr/local/www/nginx, mas atualmente, este é um link simbólico para o diretório /usr/local/www/nginx-dist que pode ser atualizado por uma operação de pacote no futuro.

Devemos destruir o link e criar novamente o diretório desvinculado:

sudo rm /usr/local/www/nginx
sudo mkdir /usr/local/www/nginx

Como ainda precisamos testar nosso servidor web, podemos copiar o arquivo index.html para nossa nova raiz da web:

sudo cp /usr/local/www/nginx-dist/index.html /usr/local/www/nginx

Enquanto estivermos aqui, também devemos criar um arquivo temporário info.php que podemos usar para testar a capacidade do Nginx de passar pedidos para PHP-FPM. Crie o arquivo dentro da raiz do documento com privilégios sudo:

sudo vi /usr/local/www/nginx/info.php

No arquivo, digite os seguintes conteúdos. Isso gerará uma página HTML com informações sobre nossa configuração do PHP:

<?php phpinfo(); ?>

Salve e feche o arquivo quando terminar.

Agora estamos prontos para reiniciar o Nginx e aproveitar nossa nova configuração. Primeiro, teste seu arquivo de configuração para verificar se existem erros de sintaxe digitando:

sudo nginx -t

Se o seu arquivo de configuração não tiver erros de sintaxe detectáveis, você deve ver algo que se parece com isto:

nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful

Se o comando acima retornar com erros, reabra o arquivo de configuração Nginx para o local onde o erro foi encontrado e tente resolver o problema.

Quando sua configuração estiver correta, podemos reiniciar o Nginx:

sudo service nginx restart

Conferindo Resultados

Nossa configuração de Web Server está completa. Tudo o que resta para fazer é testá-la.

Em seu navegador da Web, comece por acessar seu nome de domínio ou o endereço IP do servidor:

http://example.com

Você deve ver o conteúdo do arquivo index.html que copiamos. Vai parecer algo assim:

Como Instalar Um Nginx, MySQL E PHP (FEMP) Stack No FreeBSD 10.1
Teste NGINX

Isso indica que o Nginx está funcionando e capaz de exibit páginas HTML simples.

Em seguida, devemos verificar o arquivo info.php que criamos. No seu navegador, visite seu nome de domínio ou endereço IP do servidor, seguido de /info.php:

http://example.com/info.php

Você deve ver a pagína de informações do PHP, algo parecido com isto:

Como Instalar Um Nginx, MySQL E PHP (FEMP) Stack No FreeBSD 10.1
Teste PHP

Se você pode ver esta página, você configurou com sucesso uma FEMP Stack em seu servidor FreeBSD.

Depois de testar sua configuração, o bom senso manda remover o arquivo info.php de seu servidor, pois pode fornecer algumas informações confidenciais sobre sua instalação:

sudo rm /usr/local/www/nginx/info.php

Você sempre pode recriar este arquivo facilmente em um momento posterior.

Conclusão

Agora você deve ter um servidor web totalmente funcional alimentado por Nginx que pode processar o conteúdo PHP dinâmico e usar o MySQL para armazenar dados. Esta configuração pode ser usada como base para uma variedade de outras configurações e aplicações web. Nesta dica, você viu como instalar um Nginx, MySQL e PHP (FEMP) Stack no FreeBSD esperamos ter ajudado.

Escrito por Edgar

Quem sou eu? Uma pessoa em constante mudança, buscando novas maneiras de pensar e transformar a interação humana com o mundo a sua volta, em resumo, sou um UX Designer em Portugal.

Na minha vida profissional, implementei soluções criativas para algumas brandings Brasileiras, Americanas (USA) e Europeias (Continente).