Criando e Executando um Projeto Webman no ServBay

O que é o Webman?

Webman é um framework web assíncrono de alta performance para PHP, baseado no Workerman, projetado para aplicações web que exigem alta concorrência e bom desempenho. Diferente dos frameworks tradicionais de modelo síncrono e bloqueante, o Webman utiliza uma arquitetura orientada a eventos e I/O assíncrono não bloqueante, proporcionando excelente resposta sob grande volume de pedidos simultâneos. Ele oferece APIs simples, fáceis de usar e um sistema flexível de extensões — ideal para aplicativos em tempo real, APIs, microsserviços e muito mais.

Principais Características e Vantagens do Webman

• Alta performance: Baseado no Workerman, aproveita eventos e I/O assíncrono para lidar com conexões massivas, alcançando uma taxa de processamento muito superior aos frameworks tradicionais e síncronos.
• Facilidade de uso: Possui APIs diretas e intuitivas, além de diversas funcionalidades nativas, permitindo desenvolvimento rápido e produtivo.
• Suporte a múltiplos protocolos: Suporte interno para HTTP, WebSocket e outros protocolos de aplicação, facilitando a criação de diferentes tipos de serviços.
• Expansão flexível: Permite a ampliação das funcionalidades do framework via pacotes Composer, plugins e middlewares.
• Baixo consumo de recursos: Comparado ao modelo tradicional de servidor web + PHP-FPM, como aplicação residente na memória, o Webman consome menos recursos.
• Forte suporte da comunidade: Conta com uma comunidade ativa de desenvolvedores e documentação extensa.

Webman é a ferramenta ideal para criar aplicações web e serviços de API de alta disponibilidade e performance, especialmente úteis em cenários que demandam concorrência elevada e baixa latência.

Criando e Executando um Projeto Webman no ServBay

Este guia mostra, passo a passo, como criar e rodar um projeto básico com Webman dentro do ambiente de desenvolvimento local fornecido pelo ServBay. Cobriremos instalação do Webman, roteamento, código básico de controlador, integração de bancos de dados (MySQL, PostgreSQL) e cache (Redis, Memcached).

TIP

O ServBay recomenda armazenar todos os projetos web locais no diretório /Applications/ServBay/www, o que facilita a administração via ServBay, inclusive na hora de configurar sites locais (anteriormente chamados de "Hosts").

Pré-requisitos

Antes de começar, certifique-se de:

1. Instalar o ServBay: ServBay está corretamente instalado no seu macOS. Ele fornece um ambiente único e integrado para desenvolvimento local, englobando PHP, Composer, MySQL, PostgreSQL, Redis, Memcached e todos os componentes necessários para este tutorial.
2. Ativar os pacotes necessários: No painel de controle ServBay, garanta que os seguintes pacotes estão instalados e em execução:
   • Versão desejada do PHP (recomenda-se PHP 8.x ou superior)
   • Composer (incluso no ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Verifique que a versão do PHP escolhida está com as extensões necessárias habilitadas: memcached, redis, pdo_mysql, pdo_pgsql. Por padrão, o ServBay já ativa essas extensões, mas você pode conferir na tela de configurações do PHP no ServBay.
3. Acesso ao terminal: Esteja confortável utilizando o Terminal do macOS.

Instalando o Webman

1. Verifique se o Composer está disponível

   O Composer já é incluso no ServBay (veja aqui), pronto para uso via terminal. Para confirmar, execute:

   composer --version

   Se a versão do Composer for exibida corretamente, está tudo pronto.

2. Acesse o diretório de sites do ServBay

   No terminal, navegue até o diretório raiz recomendado para projetos web no ServBay:

   cd /Applications/ServBay/www

3. Crie o projeto Webman com Composer

   Use o comando create-project do Composer para instalar o Webman num diretório específico. Nomearemos o projeto de servbay-webman-app:

   composer create-project workerman/webman servbay-webman-app

   O Composer irá baixar o Webman e suas dependências essenciais para o novo diretório.

4. Entre no diretório do projeto

   Após a instalação, acesse o diretório recém-criado:

   cd servbay-webman-app

5. Instale os componentes necessários

   Para demonstrar banco de dados e cache, será preciso instalar alguns pacotes extras via Composer. O Webman utiliza, comumente, illuminate/database (componente do Laravel), illuminate/redis e outros. O parâmetro -W (--with-dependencies) ajuda a prevenir conflitos de dependências.

   composer require -W illuminate/database illuminate/redis illuminate/pagination illuminate/events symfony/var-dumper

   Este comando instalará o ORM de banco de dados, cliente Redis, componentes de paginação, agendador de eventos e VarDumper para depuração.

Criando o Banco de Dados e Tabelas

Para funcionamento do código exemplo, será necessário criar, em ambos MySQL e PostgreSQL, o banco de dados e a tabela users. A senha padrão do usuário root no ServBay é password.

Utilize ferramentas de gestão oferecidas pelo ServBay (phpMyAdmin, pgAdmin, acessíveis pelo painel) ou execute os comandos abaixo no terminal.

1. Crie o banco de dados webman_app

   • MySQL:

     CREATE DATABASE IF NOT EXISTS webman_app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. No banco webman_app, crie a tabela users

   • MySQL:

     USE webman_app;
     CREATE TABLE users (
         id INT AUTO_INCREMENT PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

   • PostgreSQL:

     \c webman_app; -- Conecte ao banco recém-criado
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Desenvolvendo o Código do Projeto Web

Agora vamos definir rotas, criar controladores e implementar a lógica de interação com banco de dados e cache.

1. Configure as rotas

   Edite o arquivo config/route.php no diretório do projeto, adicionando o seguinte código para definir as rotas de exemplo:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Define a rota raiz e mapeia para o método index do IndexController
   Route::any('/', [IndexController::class, 'index']);
   
   // Rotas relacionadas ao cache
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Rotas relacionadas ao banco de dados
   Route::any('/mysql-add', [DatabaseController::class, 'mysqlAdd']);
   Route::any('/mysql', [DatabaseController::class, 'mysqlGet']);
   Route::any('/pgsql-add', [DatabaseController::class, 'pgsqlAdd']);
   Route::any('/pgsql', [DatabaseController::class, 'pgsqlGet']);
   
   // Adicione mais rotas aqui se necessário...

2. Crie os arquivos dos controladores

   No diretório app/controller, crie os arquivos IndexController.php, CacheController.php e DatabaseController.php, e insira os códigos a seguir.

   • app/controller/IndexController.php: gerencia as requisições à rota raiz.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Importa a classe Response
     
     class IndexController
     {
         /**
          * Método exemplo para tratar requisições à raiz
          * @param Request $request Objeto da requisição atual
          * @return Response Retorna um objeto Response
          */
         public function index(Request $request): Response // Define explicitamente o tipo de retorno
         {
             // Retorna resposta simples em texto
             return response('Hello ServBay & Webman!'); // Mensagem de boas-vindas atualizada
         }
     }

   • app/controller/CacheController.php: demonstra uso do Memcached e Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Importa a classe Memcached
     use support\Redis; // Importa o Facade Redis do Webman
     
     class CacheController
     {
         /**
          * Demonstra o uso do Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Conecta ao servidor Memcached (ServBay padrão: 127.0.0.1:11211)
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Define um item de cache, válido por 60 segundos
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Key e valor atualizados
             if (!$success) {
                  return response('Falha ao definir chave no Memcached', 500);
             }
     
             // Busca valor do cache
             $value = $memcached->get('servbay_key'); // Key atualizada
     
             // Retorna valor encontrado
             return response($value ?: 'Chave do Memcached não encontrada ou expirada'); // Mensagem se não encontrar
         }
     
         /**
          * Demonstra o uso do Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Utiliza Facade Redis do Webman para definir cache
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Key e valor atualizados
     
             // Utiliza Facade do Webman para obter valor do cache
             $value = Redis::get('servbay_redis_key'); // Key atualizada
     
             // Retorna valor encontrado
             return response($value ?: 'Chave do Redis não encontrada'); // Mensagem se não encontrar
         }
     }

   • app/controller/DatabaseController.php: demonstra operações com MySQL e PostgreSQL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Importa o Facade Db do Webman
     
     class DatabaseController
     {
         /**
          * Adiciona usuário ao banco MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Conecta ao banco 'mysql' e insere dados
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Dados de exemplo atualizados
                     'email' => 'mysql_demo@servbay.test', // E-mail de exemplo atualizado
                     'created_at' => date('Y-m-d H:i:s') // Adiciona campo created_at
                 ]);
                 return response('Usuário adicionado ao MySQL'); // Mensagem de resposta atualizada
             } catch (\Exception $e) {
                 return response('Erro ao adicionar usuário ao MySQL: ' . $e->getMessage(), 500); // Tratamento de erro
             }
         }
     
         /**
          * Obtém lista de usuários do MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Busca todos os usuários
                 $users = Db::connection('mysql')->table('users')->get();
                 // Retorna lista de usuários em JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type definido
             } catch (\Exception $e) {
                  return response('Erro ao buscar usuários do MySQL: ' . $e->getMessage(), 500); // Tratamento de erro
             }
         }
     
         /**
          * Adiciona usuário ao banco PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Conecta ao banco 'pgsql' e insere dados
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Dados de exemplo atualizados
                     'email' => 'pgsql_demo@servbay.test', // E-mail de exemplo atualizado
                     'created_at' => date('Y-m-d H:i:s') // Adiciona campo created_at
                 ]);
                 return response('Usuário adicionado ao PostgreSQL'); // Mensagem de resposta atualizada
              } catch (\Exception $e) {
                 return response('Erro ao adicionar usuário ao PostgreSQL: ' . $e->getMessage(), 500); // Tratamento de erro
              }
         }
     
         /**
          * Obtém lista de usuários do PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Busca todos os usuários
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Retorna lista de usuários em JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Content-Type definido
              } catch (\Exception $e) {
                 return response('Erro ao buscar usuários do PostgreSQL: ' . $e->getMessage(), 500); // Tratamento de erro
              }
         }
     }

3. Configure a conexão com bancos de dados

   Edite o arquivo config/database.php no diretório do projeto para configurar MySQL e PostgreSQL. O ServBay usa por padrão o host 127.0.0.1 e portas 3306 (MySQL), 5432 (PostgreSQL). O usuário padrão é root e senha password.

   <?php
   /**
    * Configuração dos bancos de dados
    */
   return [
       // Banco padrão utilizado
       'default' => 'mysql',
   
       // Lista de configurações das conexões
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Host e porta padrão do ServBay para MySQL
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nome do banco criado anteriormente
               'database'  => 'webman_app',
               // Usuário padrão ServBay
               'username'  => 'root',
               // Senha padrão ServBay
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Host e porta padrão do ServBay para PostgreSQL
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nome do banco criado anteriormente
               'database' => 'webman_app',
                // Usuário padrão ServBay
               'username' => 'root',
                // Senha padrão ServBay
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // ou require, verify-ca, verify-full
           ],
           // Adicione novas conexões aqui...
       ],
   ];

   Atenção: Em ambientes de produção, altere a senha padrão do banco e evite expor informações sensíveis diretamente no código.

Executando o Projeto Webman

O Webman é iniciado normalmente via script start.php, rodando o processo Workerman. Diferente do método tradicional baseado em Nginx/Apache + PHP-FPM, o Webman é executado como aplicação assíncrona residente na memória.

No diretório raiz do projeto (/Applications/ServBay/www/servbay-webman-app), execute:

php start.php start

Ao executar este comando, você verá a tela de inicialização do Webman, que por padrão escuta requisições HTTP em 127.0.0.1:8787.

• Nota: O comando php refere-se ao executável PHP do ambiente ServBay. O ServBay configura o terminal automaticamente para utilizar o PHP instalado.
• Para rodar o Webman em background, utilize o parâmetro -d: php start.php start -d.
• Para parar o serviço Webman: php start.php stop.
• Para reiniciar: php start.php restart.
• Para reinício suave (sem interromper pedidos): php start.php reload.

Testando o Projeto

Com o Webman rodando e escutando em 127.0.0.1:8787, acesse os URLs abaixo no navegador para testar cada funcionalidade:

• http://localhost:8787/: Exibe Hello ServBay & Webman!.
• http://localhost:8787/memcached: Exibe Hello Memcached from ServBay!, indicando sucesso na conexão e uso do serviço Memcached do ServBay.
• http://localhost:8787/redis: Exibe Hello Redis from ServBay!, indicando sucesso na integração com o Redis do ServBay.
• http://localhost:8787/mysql-add: Exibe Usuário adicionado ao MySQL, inserindo um registro na tabela users do MySQL.
• http://localhost:8787/mysql: Exibe um JSON com a lista de usuários do MySQL.
• http://localhost:8787/pgsql-add: Exibe Usuário adicionado ao PostgreSQL, inserindo um registro em PostgreSQL.
• http://localhost:8787/pgsql: Exibe um JSON com a lista de usuários do PostgreSQL.

Caso tenha problemas ao acessar algum URL, verifique se há erros no terminal do Webman, se MySQL, PostgreSQL, Redis e Memcached estão ativos no ServBay e se as extensões PHP estão habilitadas.

Perguntas Frequentes (FAQ)

• Q: O comando php start.php start não é encontrado?
  • A: Certifique-se de estar no diretório do projeto servbay-webman-app via terminal. Além disso, verifique se o PHP instalado pelo ServBay foi devidamente inserido no PATH do sistema (o ServBay faz isso automaticamente).
• Q: Não consigo acessar localhost:8787?
  • A: Veja se há erros na tela de execução do php start.php start. Certifique-se que a porta 8787 não está ocupada por outro serviço. Se necessário, altere a porta nas configurações do Webman (config/server.php).
• Q: Falha na conexão com banco de dados?
  • A: Verifique se os serviços MySQL e PostgreSQL estão rodando no ServBay. Confira dados de conexão no config/database.php (host, porta, banco, usuário e senha). Verifique se criou o banco webman_app e a tabela users.
• Q: Problemas ao conectar ao Memcached ou Redis?
  • A: Veja se os serviços Memcached e Redis estão ativos no ServBay. Certifique os endereços/portas usados no app/controller/CacheController.php (127.0.0.1:11211 para Memcached, 127.0.0.1:6379 para Redis). Verifique se as extensões PHP memcached e redis estão habilitadas.

Conclusão

Seguindo os passos acima, você conseguiu criar, configurar e executar um projeto básico Webman usando o ambiente de desenvolvimento local do ServBay. Aprendeu a aproveitar o serviço integrado do ServBay para montar rapidamente o ambiente, incluindo banco de dados e cache. A combinação do alto desempenho do Webman com o ServBay oferece um suporte poderoso ao desenvolvimento de aplicações PHP assíncronas. Esperamos que este guia ajude você a construir soluções web ainda melhores com ServBay e Webman.