Criando e Executando um Projeto Webman no ServBay

O que é o Webman?

Webman é um framework web PHP assíncrono de alta performance, baseado no Workerman, projetado para construir aplicações web com alta concorrência e desempenho. Diferente dos frameworks tradicionais de PHP baseados em modelos síncronos e bloqueantes, o Webman utiliza um modelo dirigido por eventos e I/O assíncrono não bloqueante, o que o torna excepcional ao lidar com um grande volume de requisições simultâneas. Oferece uma API intuitiva e fácil de usar, além de um mecanismo flexível de extensões, sendo excelente para o desenvolvimento de aplicações em tempo real, APIs, microsserviços, entre outros.

Principais características e vantagens do Webman

• Alta performance: Baseado no Workerman, aproveita I/O assíncrono e orientado por eventos, processando conexões concorrentes em grande escala e atingindo throughput muito superior aos frameworks tradicionais.
• Facilidade de uso: Possui uma API simples, objetiva e repleta de recursos, permitindo que desenvolvedores iniciem rapidamente seus projetos.
• Suporte a múltiplos protocolos: Suporte nativo para HTTP, WebSocket e outros protocolos comuns do nível de aplicação, facilitando a construção de serviços diversos.
• Expansão flexível: É possível estender suas funcionalidades facilmente via pacotes Composer, plugins e middlewares.
• Baixo consumo de recursos: Como aplicação residente em memória, consome menos recursos comparado ao modelo clássico Servidor Web + PHP-FPM.
• Forte suporte comunitário: Conta com uma comunidade ativa de desenvolvedores e ampla documentação.

O Webman ajuda desenvolvedores a construir aplicações web e APIs de alta performance e disponibilidade, especialmente em cenários com alta concorrência e baixa latência.

Criando e executando um projeto Webman simples no ServBay

Este guia detalha como criar e executar um projeto web simples com o Webman usando o ambiente local de desenvolvimento do ServBay. Serão demonstrados: instalação do Webman, código básico de rotas e controladores, além da integração com bancos de dados (MySQL, PostgreSQL) e serviços de cache (Redis, Memcached) oferecidos pelo ServBay.

TIP

O ServBay recomenda que todos os projetos locais sejam armazenados em /Applications/ServBay/www, facilitando a gestão centralizada, por exemplo, na configuração de sites locais (anteriormente chamados "Hosts").

Pré-requisitos

Antes de começar, certifique-se de que:

1. ServBay está instalado: O ServBay já está devidamente instalado no seu macOS. Ele oferece um ambiente de desenvolvimento local completo, incluindo PHP, Composer, MySQL, PostgreSQL, Redis, Memcached, entre outros necessários para este tutorial.
2. Pacotes necessários habilitados: No painel do ServBay, confira se estão instalados e rodando:
   • Versão escolhida do PHP (recomendado PHP 8.x ou superior)
   • Composer (já incluído no ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Certifique-se de que sua versão de PHP selecionada possui os módulos memcached, redis, pdo_mysql, pdo_pgsql, entre outros. Por padrão, o ServBay ativa essas extensões, mas você pode conferir nas configurações do PHP pelo próprio painel.
3. Acesso ao terminal: É necessário estar familiarizado com o uso do Terminal do macOS.

Instalando o Webman

1. Verifique se o Composer está disponível

   O ServBay já inclui o Composer e está pronto para uso no terminal. Confira executando:

   composer --version

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

2. Acesse o diretório dos sites do ServBay

   No terminal, navegue até a raiz sugerida para sites pelo ServBay:

   cd /Applications/ServBay/www

3. Crie um projeto Webman usando o Composer

   Utilize o comando create-project para instalar o Webman em um diretório. Neste guia, nomeamos o projeto como servbay-webman-app:

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

   O Composer fará o download do Webman e suas dependências para a pasta servbay-webman-app.

4. Entre no diretório do projeto

   Após a instalação, acesse o novo diretório criado:

   cd servbay-webman-app

5. Instale os componentes necessários

   Para demonstrar bancos de dados e cache, instale alguns pacotes adicionais via Composer. O Webman costuma utilizar illuminate/database (o ORM do Laravel), illuminate/redis etc. O parâmetro -W (--with-dependencies) garante a resolução adequada de dependências:

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

   Esse comando instala o ORM, o cliente Redis, componentes de paginação, gestão de eventos e o VarDumper para debugging.

Criando banco de dados e tabela

Para os exemplos funcionarem, crie o banco e a tabela users tanto no MySQL quanto no PostgreSQL via ServBay. O usuário padrão root do banco no ServBay tem senha password.

Utilize as ferramentas de gerenciamento fornecidas pelo ServBay (phpMyAdmin, pgAdmin via painel) ou comandos no terminal para executar:

1. Crie o banco webman_app

   • MySQL:

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

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Crie a tabela users no banco webman_app

   • 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; -- conecta ao banco 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
     );

Escrevendo o código do projeto Web

A seguir, vamos adicionar código para definir rotas, criar controladores e gerenciar a lógica de interação com banco de dados e cache.

1. Configuração das rotas

   Edite o arquivo config/route.php na raiz do seu projeto e inclua as rotas abaixo:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Define a rota da raiz, mapeando para o método index do IndexController
   Route::any('/', [IndexController::class, 'index']);
   
   // Rotas de demonstração de cache
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Rotas de demonstração de 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']);
   
   // Você pode adicionar mais rotas aqui...

2. Criação dos arquivos de controladores

   Crie os arquivos IndexController.php, CacheController.php e DatabaseController.php em app/controller/, incluindo os seguintes códigos:

   • app/controller/IndexController.php: responsável pela rota principal.

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

   • app/controller/CacheController.php: para demonstrar 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 fornecido pelo Webman
     
     class CacheController
     {
         /**
          * Demonstra o uso do Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Conecta ao servidor Memcached – ServBay rodando em 127.0.0.1:11211
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Define o item no cache com tempo de expiração de 60s
             $success = $memcached->set('servbay_key', 'Hello Memcached from ServBay!', 60); // Chave e valor de demonstração
             if (!$success) {
                  return response('Failed to set Memcached key', 500);
             }
     
             // Recupera o valor do cache
             $value = $memcached->get('servbay_key'); // Chave de demonstração
     
             // Retorna o valor recuperado
             return response($value ?: 'Memcached key not found or expired'); // Mensagem caso não exista
         }
     
         /**
          * Demonstra o uso do Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Salva valor usando o Facade Redis
             Redis::set('servbay_redis_key', 'Hello Redis from ServBay!'); // Chave e valor de demonstração
     
             // Recupera valor usando o Facade Redis
             $value = Redis::get('servbay_redis_key'); // Chave de demonstração
     
             // Retorna o valor recuperado
             return response($value ?: 'Redis key not found'); // Mensagem caso não exista
         }
     }

   • app/controller/DatabaseController.php: para operações no 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 {
                 // Usa o Db Facade para inserir dados no MySQL
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'ServBay Webman MySQL User', // Dados de exemplo
                     'email' => '[email protected]', // Email de exemplo
                     'created_at' => date('Y-m-d H:i:s') // Adiciona created_at
                 ]);
                 return response('User added to MySQL'); // Mensagem de sucesso
             } catch (\Exception $e) {
                 return response('Error adding user to MySQL: ' . $e->getMessage(), 500); // Erro tratado
             }
         }
     
         /**
          * Recupera lista de usuários do MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Usa o Db Facade para consultar todos usuários no MySQL
                 $users = Db::connection('mysql')->table('users')->get();
                 // Retorna a lista em formato JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Define Content-Type
             } catch (\Exception $e) {
                  return response('Error getting users from MySQL: ' . $e->getMessage(), 500); // Erro tratado
             }
         }
     
         /**
          * Adiciona usuário ao banco PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Usa o Db Facade para inserir dados no PostgreSQL
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'ServBay Webman PgSQL User', // Dados de exemplo
                     'email' => '[email protected]', // Email de exemplo
                     'created_at' => date('Y-m-d H:i:s') // Adiciona created_at
                 ]);
                 return response('User added to PostgreSQL'); // Mensagem de sucesso
              } catch (\Exception $e) {
                 return response('Error adding user to PostgreSQL: ' . $e->getMessage(), 500); // Erro tratado
              }
         }
     
         /**
          * Recupera lista de usuários do PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Usa o Db Facade para consultar todos usuários no PostgreSQL
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Retorna a lista em formato JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Define Content-Type
              } catch (\Exception $e) {
                 return response('Error getting users from PostgreSQL: ' . $e->getMessage(), 500); // Erro tratado
              }
         }
     }

3. Configuração da conexão do banco de dados

   Edite o arquivo config/database.php na raiz do projeto para ajustar a conexão com MySQL e PostgreSQL. Os parâmetros padrão no ServBay são: host 127.0.0.1, porta 3306 (MySQL) e 5432 (PostgreSQL), usuário root, senha password:

   <?php
   /**
    * Configuração de bancos de dados
    */
   return [
       // Conexão padrão
       'default' => 'mysql',
   
       // Lista de conexões
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // MySQL padrão do ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nome do banco criado
               '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',
               // PostgreSQL padrão do ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nome do banco criado
               '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 mais conexões se necessário...
       ],
   ];

   Aviso importante: Em ambientes de produção, altere a senha padrão do banco e evite hardcoding de dados sensíveis no código.

Executando o projeto Webman

Projetos Webman são usualmente iniciados via o script start.php, que executa os processos Workerman. Diferente do padrão Nginx/Apache + PHP-FPM, o Webman roda como aplicação assíncrona residente em memória.

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

php start.php start

Você verá uma mensagem de inicialização do Webman, que por padrão escuta requisições HTTP na porta 127.0.0.1:8787.

• Nota: O comando php utiliza o executável do PHP fornecido pelo ServBay. O ServBay configura o ambiente do terminal para que você use a versão do PHP instalada pelo próprio ServBay.
• Para rodar o Webman em segundo plano acrescente -d: php start.php start -d.
• Para parar o serviço Webman: php start.php stop.
• Para reiniciar o Webman: php start.php restart.
• Para reiniciar suavemente (sem terminar requisições em andamento): php start.php reload.

Testando o projeto

Após o Webman iniciar e escutar em 127.0.0.1:8787, acesse os seguintes URLs no navegador para testar cada funcionalidade:

• http://localhost:8787/ – Deverá exibir Hello ServBay & Webman!.
• http://localhost:8787/memcached – Deverá exibir Hello Memcached from ServBay!. Isso significa que seu Webman se conectou ao Memcached do ServBay com sucesso.
• http://localhost:8787/redis – Deverá exibir Hello Redis from ServBay!. Isso indica conexão bem-sucedida com o Redis do ServBay via Webman.
• http://localhost:8787/mysql-add – Deverá exibir User added to MySQL, cadastrando um registro na tabela users do MySQL.
• http://localhost:8787/mysql – Exibe a lista de usuários do banco MySQL em formato JSON.
• http://localhost:8787/pgsql-add – Exibe User added to PostgreSQL, cadastrando um registro na tabela do PostgreSQL.
• http://localhost:8787/pgsql – Exibe a lista de usuários do PostgreSQL em formato JSON.

Se encontrar dificuldades ao acessar os URLs acima, verifique no terminal possíveis erros exibidos na inicialização do Webman, além de conferir se os pacotes MySQL, PostgreSQL, Redis e Memcached estão ativos no painel do ServBay e se as extensões PHP necessárias estão habilitadas.

Perguntas frequentes (FAQ)

• Q: O comando php start.php start não é encontrado?
  • A: Certifique-se de que você está no diretório do projeto servbay-webman-app no terminal. Confira ainda se o PHP do ServBay está no seu PATH (o próprio ServBay normalmente configura isso).
• Q: Erro de conexão ao acessar localhost:8787?
  • A: Verifique a saída do comando php start.php start no terminal para possíveis erros. Confirme se a porta 8787 está livre e, caso precise, altere a porta em config/server.php.
• Q: Falha ao conectar ao banco de dados?
  • A: Confira se os serviços MySQL e PostgreSQL estão rodando no ServBay e se os dados de conexão em config/database.php batem com as configurações do ServBay (usuário padrão root, senha password). Certifique-se de ter criado o banco webman_app e a tabela users.
• Q: Falha ao conectar Memcached ou Redis?
  • A: Verifique se ambos estão rodando no ServBay. Confira os endereços e portas em app/controller/CacheController.php (127.0.0.1:11211 para Memcached e 127.0.0.1:6379 para Redis). Certifique-se de que o PHP possui as extensões memcached e redis habilitadas.

Conclusão

Seguindo os passos acima, você criou, configurou e executou com sucesso um projeto Webman básico em seu ambiente local utilizando o ServBay. Você aprendeu a montar um ambiente completo de desenvolvimento Webman com os serviços integrados do ServBay e a trabalhar com bancos de dados e cache. A performance do Webman, aliada à praticidade do ServBay, oferece uma base poderosa para desenvolver aplicações PHP assíncronas de alta performance. Esperamos que este guia o ajude a aproveitar ao máximo o ServBay e o Webman na criação de aplicações web de qualidade.