Construindo Aplicações PHP de Alta Performance com Swoole no ServBay

O ServBay é um ambiente local de desenvolvimento web projetado para desenvolvedores, já integrado com diversas linguagens, bancos de dados e ferramentas, com o objetivo de simplificar o fluxo de trabalho do desenvolvimento local. Este artigo destaca como utilizar a extensão Swoole no ambiente ServBay para potencializar suas aplicações PHP, construindo serviços de rede de alta performance.

O que é Swoole?

Swoole é um mecanismo de comunicação de rede paralelo e de alta performance, baseado em corrotinas (coroutines) e desenvolvido especificamente para PHP. É escrito em C puro e fornece ao PHP capacidades assíncronas, de paralelismo e comunicação de rede com corrotinas. Com o Swoole, desenvolvedores PHP podem superar as limitações do tradicional modelo de requisição-resposta dos servidores web (como Apache/Nginx + PHP-FPM) e lidar com tarefas altamente concorrentes de forma mais eficiente, como construir servidores web residentes em memória, processar tarefas assíncronas ou implementar serviços de comunicação em tempo real (como WebSocket).

Principais características do Swoole:

• Alta performance: Implementado em C a nível de base, oferecendo IO assíncrono, suporte a multiprocessos/multithread.
• Corrotinas: Proporciona corrotinas leves, permitindo execução assíncrona de código síncrono e simplificando a programação assíncrona no PHP.
• Suporte a múltiplos protocolos: Suporte nativo para TCP, UDP, HTTP, WebSocket e outros protocolos de rede.
• Fácil de usar: API simples e compatível com padrões e hábitos dos desenvolvedores PHP.
• Processos residentes: Suas aplicações podem rodar como processos residentes em memória, evitando a sobrecarga de inicialização a cada requisição, típica dos apps PHP tradicionais.

Com a ajuda do Swoole, o PHP deixa de ser apenas uma linguagem de script para web, passando a atender a uma gama bem mais ampla de cenários de aplicações de rede de alta performance.

Como habilitar o Swoole no ServBay

Um dos principais objetivos do ServBay é permitir que desenvolvedores administrem e utilizem facilmente várias extensões PHP. Swoole, peça-chave para o desenvolvimento PHP de alta performance, já vem pré-instalado no ServBay. Você só precisa de alguns passos simples para habilitá-lo.

Pré-requisitos:

• Ter o ServBay instalado e em execução.
• Certificar-se de que pelo menos uma versão do PHP está instalada no ServBay.

Passos para habilitação:

1. Abra a interface do aplicativo ServBay.
2. Navegue até a seção “Pacotes (Packages)” ou à interface de gerenciamento de versões do PHP. (Observação: O nome do menu pode variar de acordo com a versão do ServBay, geralmente fica na interface principal ou em Configurações)
3. Escolha a versão do PHP em que você deseja habilitar o Swoole.
4. Localize a opção da extensão Swoole e marque para habilitar. O ServBay normalmente exibe as extensões pré-compiladas em uma lista ou como opções de alternância.
5. Salve as alterações e reinicie o ServBay ou o serviço PHP correspondente conforme indicado. O ServBay cuidará automaticamente da configuração do ambiente PHP para carregar a extensão Swoole.

Após executar esses passos, você já pode usar o Swoole na versão do PHP selecionada. Para confirmar, execute o comando php -m no terminal e verifique se swoole está listado entre as extensões carregadas.

TIP

Por padrão, o ServBay recomenda salvar seus sites e projetos na pasta /Applications/ServBay/www. Isso facilita o gerenciamento e a configuração dos sites no ServBay. Nos exemplos deste artigo, também vamos utilizar este caminho sugerido.

Construindo um Servidor HTTP Simples com Swoole

Vamos criar um servidor HTTP básico com Swoole, mostrando como processar requisições web.

Passo 1: Crie o diretório do projeto

Abra o terminal e crie um novo diretório de projeto, navegando até ele. Conforme recomendado pelo ServBay, utilize /Applications/ServBay/www:

cd /Applications/ServBay/www
mkdir servbay-swoole-http
cd servbay-swoole-http

Passo 2: Escreva o script do servidor

No diretório servbay-swoole-http, crie um arquivo chamado server.php e adicione o seguinte conteúdo:

<?php

use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;

// Cria uma instância do servidor HTTP Swoole
// Escuta todos os endereços de rede (0.0.0.0) na porta 9501
$server = new Server("0.0.0.0", 9501);

// Registra a função de callback para o evento 'start'
// Acionada quando o servidor inicia com sucesso
$server->on("start", function (Server $server) {
    echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
    // Aqui você pode registrar IDs do processo principal, de gerenciamento, etc.
});

// Registra a função de callback para o evento 'request'
// Acionada quando o servidor recebe uma nova requisição HTTP
$server->on("request", function (Request $request, Response $response) {
    // Define o cabeçalho de resposta
    $response->header("Content-Type", "text/plain");

    // Processamento com base no caminho da requisição ou parâmetros
    $path = $request->server['request_uri'] ?? '/';
    $content = "Hello ServBay!";

    if ($path === '/info') {
        $content = "Caminho da requisição: " . $path . "\n";
        $content .= "Método: " . $request->server['request_method'] . "\n";
        $content .= "IP do cliente: " . $request->server['remote_addr'] . "\n";
        // Mais informações sobre a requisição podem ser obtidas via o objeto $request
    }

    // Envia o corpo da resposta e encerra a requisição
    $response->end($content);
});

// Inicia o servidor
$server->start();

Este script cria um servidor HTTP com Swoole escutando na porta 9501. Quando uma requisição é recebida, ele responde com o texto "Hello ServBay!". Se você acessar o caminho /info, ele retorna algumas informações sobre a requisição.

Passo 3: Execute o servidor Swoole

Certifique-se de que o terminal está no diretório servbay-swoole-http. Use a versão do PHP (com Swoole habilitado) do ServBay para rodar o script:

php server.php

Se tudo correr bem, você verá a seguinte saída no terminal:

Swoole HTTP server is started at http://0.0.0.0:9501

Isso significa que o servidor HTTP Swoole está rodando em segundo plano, escutando na porta 9501.

Passo 4: Acesse o servidor Swoole

Abra seu navegador de internet e acesse os endereços:

• http://localhost:9501
• http://localhost:9501/info

Você verá na página o texto Hello ServBay! ou, no caso do /info, informações sobre a requisição.

Para interromper o servidor, volte ao terminal onde está rodando o script e pressione Ctrl + C.

Usando Swoole para Conexões WebSocket

O Swoole oferece suporte nativo ao protocolo WebSocket, tornando-o ideal para aplicações de comunicação em tempo real, como chats, jogos online, push de dados em tempo real, entre outros.

Passo 1: Crie o script do servidor WebSocket

No diretório /Applications/ServBay/www/servbay-swoole-http (ou, se preferir, em um novo diretório, como servbay-swoole-websocket), crie um arquivo chamado websocket_server.php e adicione o conteúdo abaixo:

<?php

use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;

// Cria uma instância do servidor WebSocket Swoole
// O servidor WebSocket herda do HTTP e também pode lidar com requisições HTTP
$server = new Server("0.0.0.0", 9502); // Escuta na porta 9502

// Registra o evento 'start', acionado quando o servidor inicia
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});

// Registra o evento 'open'
// Acionado quando uma nova conexão WebSocket é estabelecida
// O objeto $request contém informações sobre a conexão do cliente, como $request->fd (file descriptor)
$server->on("open", function (Server $server, Request $request) {
    echo "Conexão aberta: {$request->fd}\n";
    // Você pode enviar uma mensagem de boas-vindas ao cliente
    $server->push($request->fd, "Bem-vindo ao ServBay WebSocket Demo!");
});

// Registra o evento 'message'
// Acionado quando o servidor recebe uma mensagem WebSocket do cliente
// O objeto $frame contém informações da mensagem, como $frame->data (conteúdo) e $frame->fd (cliente)
$server->on("message", function (Server $server, Frame $frame) {
    echo "Mensagem recebida de {$frame->fd}: {$frame->data}\n";
    // Enviar uma resposta ao remetente ou fazer broadcast para outros clientes
    // Exemplo: responder ao remetente
    $server->push($frame->fd, "Olá, você enviou: {$frame->data}");

    // Exemplo de broadcast (necessário manter lista de conexões ou percorrer)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // Não enviar para o remetente
    //         $server->push($fd, "Usuário {$frame->fd} disse: {$frame->data}");
    //     }
    // }
});

// Registra o evento 'close'
// Acionado quando o cliente fecha a conexão
$server->on("close", function ($ser, $fd) {
    echo "Conexão encerrada: {$fd}\n";
});

// Inicia o servidor
$server->start();

Este script cria um servidor WebSocket com Swoole escutando na porta 9502. Define callbacks para os principais eventos: start (início do servidor), open (nova conexão), message (recebimento de mensagem) e close (fechamento). No evento message, o servidor simplesmente ecoa a mensagem recebida para o remetente.

Passo 2: Rode o servidor WebSocket

No terminal, vá até o diretório onde está o arquivo websocket_server.php e execute usando a versão PHP com Swoole habilitado do ServBay:

php websocket_server.php

Se estiver tudo certo, a saída será:

Swoole WebSocket server is started at ws://0.0.0.0:9502

Seu servidor WebSocket já está rodando na porta 9502.

Passo 3: Conecte-se ao servidor WebSocket

Há várias formas de conectar a este servidor para fazer testes.

Método A: Usando as Ferramentas de Desenvolvedor do Navegador

A maioria dos navegadores atuais possui a aba “Console” ou “Network” nas ferramentas de desenvolvedor (geralmente abertas com F12), permitindo testar conexões WebSocket.

1. Abra qualquer página (p.ex., about:blank) no navegador.

2. Abra as ferramentas de desenvolvedor, vá para o painel “Console”.

3. Digite o seguinte código JavaScript para se conectar:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("Conexão WebSocket aberta:", event);
     ws.send("Olá do Navegador!"); // Envia mensagem após conexão aberta
   };
   
   ws.onmessage = function(event) {
     console.log("Mensagem do servidor:", event.data); // Recebe resposta
   };
   
   ws.onerror = function(event) {
     console.error("Erro WebSocket:", event);
   };
   
   ws.onclose = function(event) {
     console.log("Conexão WebSocket encerrada:", event);
   };
   
   // Use ws.send("sua mensagem") para enviar mensagens a qualquer momento
   // Use ws.close() para encerrar a conexão

4. Execute o código no painel do console e observe as saídas. No terminal rodando websocket_server.php você verá os logs de conexões e mensagens.

Método B: Usando o cliente de linha de comando wscat

O wscat é uma ferramenta de linha de comando para WebSocket baseada em Node.js.

1. Instale o wscat: Se ainda não tiver o Node.js/nmp instalados, instale-os antes. Então, instale o wscat globalmente:

   npm install -g wscat

2. Conecte ao servidor WebSocket: No terminal, execute:

   wscat -c ws://localhost:9502

   Após conectar, aparecerá o prompt >.

3. Envie mensagens: Digite sua mensagem e tecle Enter:

   > Olá ServBay via wscat

   O servidor devolverá uma resposta, que você verá no terminal do wscat (identificado geralmente por <):

   < Olá, você enviou: Olá ServBay via wscat

   O terminal rodando o servidor também mostrará o log do evento.

Para encerrar a conexão com o wscat, use Ctrl + C.

Observações importantes

• Conflito de portas: Verifique se as portas em que o Swoole está rodando (ex.: 9501, 9502) estão livres e não sendo usadas por outros aplicativos. Caso contrário, o servidor não iniciará.
• Versão do PHP: Garanta que está rodando os scripts usando a versão do PHP em que o Swoole está habilitado no ServBay. Use php -v para verificar a versão ativa no terminal. O ServBay oferece ferramentas práticas para alternar versões.
• Status da extensão: Se o servidor falhar ao iniciar, confira novamente se a extensão Swoole está realmente ativada na versão do PHP selecionada e se após habilitar, o ServBay ou o serviço PHP foram reiniciados.
• Gerenciamento de processos residentes: O Swoole executa como um processo residente em memória. Em produção, utilize ferramentas como Supervisor, Systemd, pm2 etc. para monitorar e reiniciar automaticamente o processo em caso de falha. No ambiente local com o ServBay, geralmente rodar diretamente no terminal já é suficiente.

Conclusão

Com o ServBay, você pode facilmente ativar e usar a extensão Swoole para construir e testar aplicações PHP de alta performance no seu ambiente local – seja para serviços HTTP tradicionais ou para aplicações WebSocket modernas em tempo real. O poder do Swoole, aliado à praticidade do ServBay, abre novas portas para desenvolvedores PHP criarem aplicações mais eficientes e robustas. Experimente agora o Swoole no ServBay e leve sua produtividade a outro nível!