Criando e Executando Projetos ThinkPHP 8 no ServBay

Este guia mostrará como usar o ServBay, um poderoso ambiente local de desenvolvimento Web, para criar, configurar e executar rapidamente um projeto PHP baseado no framework ThinkPHP 8. O ServBay oferece ambientes PHP pré-configurados, servidores Web (Caddy ou Nginx) e diversos bancos de dados, simplificando bastante o processo de setup local para projetos ThinkPHP.

O que é ThinkPHP?

ThinkPHP é um framework PHP open-source, rápido, simples e orientado a objetos originado na China. Ele segue os princípios de desenvolvimento enxuto e eficiente, oferecendo um conjunto de ferramentas práticas para criar aplicações Web modernas. ThinkPHP é amplamente utilizado no desenvolvimento PHP na China graças à sua facilidade de uso, funcionalidades robustas (como ORM poderoso, roteamento flexível, sistema de templates embutido, suporte a cache, etc.) e uma comunidade ativa.

Principais Características e Vantagens do ThinkPHP

Enxuto e eficiente: Estrutura de código simples, clara e fácil de manter, promovendo alta produtividade no desenvolvimento.
Funcionalidades completas: Inclui componentes essenciais como MVC, ORM, engine de template, cache, gerenciamento de sessão, autenticação, tokens de formulário, entre outros.
ORM poderoso: Fornece um mapeamento objeto-relacional robusto e fácil de usar, facilitando operações com bancos de dados.
Roteamento flexível: Suporta várias formas de definição de rotas, atendendo a URLs complexas.
Ecossistema rico: Diversas bibliotecas e plugins, além de uma grande e ativa comunidade de desenvolvedores.
Atualizações constantes: Evolui rapidamente para acompanhar as tendências do PHP e do desenvolvimento Web.

O ThinkPHP é adequado tanto para pequenos projetos quanto para grandes aplicações empresariais.

Preparando um Projeto ThinkPHP 8 com o ServBay

O ServBay oferece um ambiente ideal para desenvolvimento local com ThinkPHP 8, incluindo:

Diversas versões do PHP com extensões úteis pré-instaladas.
Servidor Web integrado (Caddy ou Nginx) que facilita a configuração de sites.
Integração com MySQL, PostgreSQL, MongoDB, Redis, Memcached e outros bancos de dados.
Composer gerenciador de dependências já embutido.

Este tutorial irá mostrar como usar essas funcionalidades do ServBay para criar rapidamente seu projeto ThinkPHP 8.

Pré-requisitos

Antes de começar, certifique-se de:

Baixou e instalou o ServBay em seu macOS.
O ServBay está em execução, com a versão necessária do PHP (ThinkPHP 8 requer PHP 8.0 ou superior) e bancos de dados relevantes (MySQL, PostgreSQL, Redis, Memcached etc.) já iniciados. Você pode gerenciar isso na aba “Pacotes” do painel do ServBay.

Criando um Projeto ThinkPHP

O ServBay recomenda que seus sites locais fiquem salvos em /Applications/ServBay/www para facilitar a gestão.

Confirme a instalação do Composer
O ServBay já vem com o Composer pré-instalado, geralmente não sendo necessária nenhuma ação extra. No terminal do ServBay, execute composer --version para verificar.
Criando o projeto ThinkPHP com Composer
No terminal do macOS, execute os comandos abaixo para criar um novo projeto ThinkPHP 8 na raiz dos sites do ServBay:
bash
```
cd /Applications/ServBay/www
composer create-project topthink/think servbay-thinkphp-app
```
1
2
Isso criará a pasta servbay-thinkphp-app em /Applications/ServBay/www, baixando o core e as dependências do ThinkPHP 8.
Acesse o diretório do projeto
Após a criação do projeto, entre na pasta:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
```
1

Inicializando as Configurações do Projeto

Depois da criação, algumas configurações básicas são necessárias.

Configurar os dados de acesso ao banco de dados

As configurações do banco de dados do ThinkPHP ficam geralmente no arquivo config/database.php. Ajuste conforme o banco iniciado no ServBay.

Exemplo de configuração para o MySQL padrão do ServBay:

php

<?php
// config/database.php

return [
    // Configuração padrão da conexão com banco de dados
    'default'         => env('database.driver', 'mysql'),

    // Configurações de cada conexão
    'connections'     => [
        'mysql' => [
            // Tipo de banco de dados
            'type'     => 'mysql',
            // Endereço do servidor
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Nome do banco de dados
            'database' => env('database.database', 'servbay_thinkphp_app'), // Recomenda-se um banco exclusivo p/ cada projeto
            // Nome de usuário
            'username' => env('database.username', 'root'),
            // Senha
            'password' => env('database.password', 'password'), // Senha padrão do ServBay – use apenas em dev local!
            // Porta
            'hostport' => env('database.hostport', '3306'),
            // ... outras configurações ...
        ],
        // ... outras conexões ...
    ],
];

Importante:

Altere o valor de database para o nome real do banco criado para o projeto (crie este banco via phpMyAdmin ou Adminer do ServBay, por exemplo).
O usuário root e senha padrão do ServBay é password. Use apenas para desenvolvimento local! Nunca utilize em produção. Em produção, crie uma senha forte e utilize usuários de acesso restrito.
Se utilizar o arquivo .env para variáveis de ambiente, garanta que suas configurações sobrescrevem os valores padrões do config/database.php.

Configurando o Servidor Web

O arquivo de entrada do ThinkPHP é o public/index.php e depende de regras de URL rewrite para roteamento. Por conta do roteamento diferenciado do ThinkPHP, deve-se usar as regras prontas do ServBay.

No painel do site no ServBay, selecione a opção de Rewrite ThinkPHP e salve.

Para detalhes sobre como configurar seu site no ServBay, consulte Adicionando o primeiro site.

Adicionando Código de Exemplo

Para testar a configuração e funcionamento básico do ThinkPHP, adicione uma rota e um controlador simples.

Edite /Applications/ServBay/www/servbay-thinkphp-app/route/app.php e inclua:

php

<?php
// route/app.php

use think\facade\Route;

// Define a rota servbay. Ao acessar /servbay, executa função anônima
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... outras rotas ...

Acessando Seu Site

Depois disso, abra o navegador e acesse o domínio local e rota de exemplo configurados:

https://thinkphp.servbay.demo/servbay

Se tudo estiver ok, verá na tela: Hello ServBay! — o que indica que o projeto ThinkPHP 8 está rodando corretamente no ambiente ServBay, com servidor Web e PHP-FPM funcionando.

Exemplos com Bancos NoSQL

O ServBay traz diversos bancos NoSQL como Memcached e Redis. O ThinkPHP conta com uma camada de cache abstrata que permite fácil integração dessas soluções como drivers de cache.

Exemplo com Memcached

Instalando a extensão Memcached
O pacote PHP do ServBay já inclui a extensão Memcached. Basta garantir que o serviço Memcached esteja ativo na aba “Pacotes” do painel ServBay.

Configurando o cache Memcached

No arquivo config/cache.php, configure o uso do Memcached como driver:

php

<?php
// config/cache.php

return [
    // Driver de cache padrão
    'default' => env('cache.driver', 'memcached'),

    // Configurações de conexão de cache
    'stores'  => [
        'memcached' => [
            // Tipo de cache
            'type'       => 'memcached',
            // Lista de servidores
            'host'       => '127.0.0.1', // Endereço padrão do Memcached no ServBay
            'port'       => 11211, // Porta padrão Memcached
            'persistent' => false,
            'expire'     => 0,
            'timeout'    => 0,
            'prefix'     => '',
        ],
        // ... outros drivers de cache ...
    ],
];

Usando o cache Memcached no código

Em seu controlador ou rota, utilize o Facade Cache do ThinkPHP:

php

<?php
use think\facade\Cache;
use think\facade\Route;

Route::get('/memcached-example', function () {
    // Seta o cache, válido por 600 segundos
    Cache::set('my_memcached_key', 'Este valor vem do Memcached!', 600);

    // Recupera o valor do cache
    $value = Cache::get('my_memcached_key');

    return 'Valor do Memcached: ' . $value;
});

Acesse https://thinkphp.servbay.demo/memcached-example para testar.

Exemplo com Redis

Instalando a extensão Redis
O pacote PHP do ServBay já inclui a extensão Redis. Apenas certifique-se de que o serviço Redis está ativo no painel ServBay.

Configurando o cache Redis

No arquivo config/cache.php, ajuste para usar Redis como driver:

php

<?php
// config/cache.php

return [
    // Driver de cache padrão
    'default' => env('cache.driver', 'redis'),

    // Configurações de conexão de cache
    'stores'  => [
        'redis' => [
            // Tipo de cache
            'type'       => 'redis',
            // Endereço do servidor
            'host'       => env('cache.host', '127.0.0.1'), // Endereço padrão do Redis no ServBay
            // Porta
            'port'       => env('cache.port', 6379), // Porta padrão Redis
            // Senha (ServBay padrão: nenhuma)
            'password'   => env('cache.password', ''), // ServBay sem senha por padrão
            'select'     => 0,
            'timeout'    => 0,
            'expire'     => 0,
            'persistent' => false,
            'prefix'     => '',
        ],
        // ... outros drivers de cache ...
    ],
];

Atenção: O Redis do ServBay, por padrão, não possui senha. Se você definir uma senha, atualize o campo password.

Usando o cache Redis no código

Use o Facade Cache do ThinkPHP nas suas rotas/controladores:

php

<?php
use think\facade\Cache;
use think\facade\Route;

Route::get('/redis-example', function () {
    // Seta valor permanente (ou defina tempo no terceiro parâmetro)
    Cache::set('my_redis_key', 'Olá do Redis!');

    // Obtém o cache
    $value = Cache::get('my_redis_key');

    return 'Valor do Redis: ' . $value;
});

Acesse https://thinkphp.servbay.demo/redis-example para testar.

Exemplos com Bancos Relacionais

O ServBay integra bancos relacionais líderes de mercado como MySQL e PostgreSQL. O ORM do ThinkPHP facilita interações com esses bancos.

Utilizando a Ferramenta de Migração do ThinkPHP

No ThinkPHP, migrar o banco via migrations ajuda no versionamento e colaboração em equipes.

Instale a extensão de migração

No diretório raiz do projeto, use o Composer:

bash

cd /Applications/ServBay/www/servbay-thinkphp-app
composer require topthink/think-migration

Crie um arquivo de migration
Gere uma migration para, por exemplo, criar a tabela users:
bash
```
php think migrate:create CreateUserTable
```
1
O arquivo será criado no diretório database/migrations (ex: 20231027100000_create_user_table.php).

Edite o arquivo de migration

No migration criado, defina a estrutura da tabela users no método up():

php

<?php
// database/migrations/YYYYMMDDHHMMSS_create_user_table.php

use think\migration\Migrator;
use think\migration\db\Column;

class CreateUserTable extends Migrator
{
    /**
     * Método Change.
     *
     * Escreva migrações reversíveis neste método.
     *
     * Mais informações: http://docs.phinx.org/en/latest/migrations.html#the-change-method
     *
     * Os comandos abaixo podem ser revertidos com rollback:
     *
     * createTable
     * renameTable
     * addColumn
     * addCustomColumn
     * renameColumn
     * addIndex
     * addForeignKey
     * createDatabase
     * renameDatabase
     * dropTable
     * dropColumn
     * dropIndex
     * dropForeignKey
     */
    public function change()
    {
        // Cria a tabela com método createTable
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nome do usuário'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Endereço de email'])
              ->addIndex(['email'], ['unique' => true]) // Adiciona index único
              ->addTimestamps() // Cria campos created_at e updated_at
              ->create(); // Executa a criação
    }

    // Alternativamente, use up() e down() separados
    /*
    public function up()
    {
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nome do usuário'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Endereço de email'])
              ->addIndex(['email'], ['unique' => true])
              ->addTimestamps()
              ->create();
    }

    public function down()
    {
        $this->dropTable('users');
    }
    */
}

Execute a migration no banco
Dentro do terminal do ServBay, estando na raiz do projeto, rode:
bash
```
php think migrate:run
```
1
Ao final, a tabela users será criada no banco de dados.

Exemplo com MySQL

Supondo que o serviço MySQL já está iniciado no ServBay e configurado no config/database.php conforme orientação.

Verifique a configuração de conexão
Consulte a seção “Inicializando as Configurações do Projeto” para garantir que as credenciais estejam corretas.

Inserindo dados na tabela users via código

Use o Facade Db do ThinkPHP ou o ORM:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/mysql-add-user', function () {
    try {
        Db::table('users')->insert([
            'name' => 'Usuário Demo ServBay',
            'email' => '[email protected]', // email de exemplo da marca
            'created_at' => date('Y-m-d H:i:s'), // se necessário, inclua manualmente os timestamps
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        return 'Usuário adicionado com sucesso!';
    } catch (\Exception $e) {
        return 'Erro ao adicionar usuário: ' . $e->getMessage();
    }
});

Acesse https://thinkphp.servbay.demo/mysql-add-user para testar.

Listando dados da tabela users

Novamente, usando o Db ou o ORM:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/mysql-users', function () {
    $users = Db::table('users')->select(); // Seleciona todos os usuários
    return json($users); // Retorna em formato JSON
});

Acesse https://thinkphp.servbay.demo/mysql-users para ver os dados.

Exemplo com PostgreSQL

Com o PostgreSQL em execução no ServBay e devidamente configurado.

Configure a conexão PostgreSQL

Em config/database.php, garanta que há uma configuração como esta (ajuste conforme o necessário):

php

<?php
// config/database.php (trecho)

return [
    // ... outras configs ...

    'connections'     => [
        // ... configurações do MySQL ...

        'pgsql' => [
            // Tipo de banco
            'type'     => 'pgsql',
            // Endereço
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Nome do banco
            'database' => env('database.database', 'servbay_thinkphp_app'), // Recomenda-se banco exclusivo p/ o projeto
            // Usuário
            'username' => env('database.username', 'root'),
            // Senha
            'password' => env('database.password', 'password'), // Senha padrão ServBay — apenas para dev local!
            // Porta
            'hostport' => env('database.hostport', '5432'), // Porta padrão do PostgreSQL
            // ... outras configs ...
        ],
        // ... demais conexões ...
    ],
];

Importante:

Tal como no MySQL, crie um banco exclusivo para cada projeto e ajuste aqui.
ServBay também usa root/password como padrão para PostgreSQL. Use FORA de produção somente.

Inserindo dados na tabela users (PostgreSQL)

Use o Db (informando para usar a conexão pgsql):

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/pgsql-add-user', function () {
    try {
        Db::connect('pgsql')->table('users')->insert([
            'name' => 'Usuário PgSQL ServBay',
            'email' => '[email protected]', // email de exemplo da marca
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        return 'Usuário do PostgreSQL adicionado com sucesso!';
    } catch (\Exception $e) {
         return 'Erro ao adicionar usuário no PostgreSQL: ' . $e->getMessage();
    }
});

Acesse https://thinkphp.servbay.demo/pgsql-add-user para testar.

Listando dados do PostgreSQL

Execute:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/pgsql-users', function () {
    $users = Db::connect('pgsql')->table('users')->select(); // Busca dados usando conexão pgsql
    return json($users);
});

Acesse https://thinkphp.servbay.demo/pgsql-users para visualizar o conteúdo da tabela users no PostgreSQL.

Conclusão

Seguindo este passo a passo, você conseguiu criar, configurar e executar um projeto ThinkPHP 8 no ambiente local do ServBay. Você aprendeu como usar o Composer embutido, configurar o servidor Web Caddy para rotas do ThinkPHP, e integrar os bancos MySQL, PostgreSQL, Memcached e Redis.

O ServBay simplifica bastante o setup do ambiente de desenvolvimento para frameworks PHP como o ThinkPHP, permitindo que você foque no desenvolvimento de suas aplicações. Agora você pode continuar evoluindo seu app ThinkPHP aproveitando todos os recursos e softwares integrados do ServBay.

Criando e Executando Projetos ThinkPHP 8 no ServBay ​

O que é ThinkPHP? ​

Principais Características e Vantagens do ThinkPHP ​

Preparando um Projeto ThinkPHP 8 com o ServBay ​

Pré-requisitos ​

Criando um Projeto ThinkPHP ​

Inicializando as Configurações do Projeto ​

Configurando o Servidor Web ​

Adicionando Código de Exemplo ​

Acessando Seu Site ​

Exemplos com Bancos NoSQL ​

Exemplo com Memcached ​

Exemplo com Redis ​

Exemplos com Bancos Relacionais ​

Utilizando a Ferramenta de Migração do ThinkPHP ​

Exemplo com MySQL ​

Exemplo com PostgreSQL ​

Conclusão ​