Criando e Executando um Projeto Yii 2 no ServBay

Visão Geral: O Que É Yii 2?

O Yii 2 é um framework PHP de alta performance, baseado em componentes, projetado para o desenvolvimento rápido de aplicações web modernas. Seguindo o padrão MVC (Model-View-Controller), ele oferece um conjunto completo de funcionalidades e ferramentas para ajudar desenvolvedores a criar aplicações web escaláveis e de alta qualidade de forma eficiente. O Yii 2 é amplamente adotado devido à sua performance, arquitetura flexível e poderosos recursos integrados, como sistemas de cache, funcionalidades de segurança e suporte à criação de APIs RESTful.

Principais Características e Vantagens do Yii 2

Alta performance: O Yii 2 é otimizado para lidar com um grande número de requisições simultâneas, ideal para construções de aplicações sensíveis a performance.
Modularidade: Sua arquitetura altamente modular facilita a organização do código e a reutilização de componentes.
Segurança: Inclui várias funcionalidades nativas de segurança, como validação de entrada, filtragem de saída, proteção contra CSRF/XSS, autenticação e autorização.
Facilidade de uso: Conta com uma API limpa, intuitiva e documentação detalhada, tornando o aprendizado e uso mais fáceis.
Comunidade ativa: Possui uma comunidade vibrante de desenvolvedores e uma vasta biblioteca de extensões de terceiros, facilitando busca por ajuda e soluções.
Ferramentas integradas: Disponibiliza ferramentas de linha de comando para tarefas como migração de banco de dados, geração de código e muito mais, aumentando a produtividade.

O Yii 2 é uma ótima escolha para aplicações empresariais, APIs RESTful, portais e diversos outros tipos de projetos web.

Executando um Projeto Yii 2 com o ServBay

O ServBay é um ambiente de desenvolvimento web local criado para macOS, integrando PHP, diversos bancos de dados (MySQL, PostgreSQL, MongoDB, Redis), servidores web (Caddy, Nginx) e outras ferramentas essenciais para desenvolvedores (Composer, Node.js, Python, Go, Java, etc.). Ele oferece uma plataforma prática, pronta para uso imediato ("out of the box").

Neste guia, vamos mostrar como criar e rodar um projeto base de Yii 2 utilizando o ambiente PHP do ServBay, Composer e os serviços de banco de dados integrados. Utilizaremos o recurso “Sites” do ServBay para configurar o servidor web local e demonstrar as funcionalidades básicas do projeto.

Pré-requisitos

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

Já instalou e está executando o ServBay no macOS.
Ativou a versão do PHP necessária no ServBay (por exemplo, PHP 8.3 ou superior).
Ativou os serviços de banco de dados desejados (por exemplo, MySQL ou PostgreSQL) e serviços de cache (Memcached e Redis) no ServBay.

Você pode visualizar e gerenciar os pacotes/serviços instalados e em execução pela interface principal do ServBay.

Criando o Projeto Yii 2

TIP

O ServBay recomenda armazenar os arquivos do seu projeto no diretório /Applications/ServBay/www. Isso mantém a estrutura organizada e facilita o gerenciamento pelo recurso “Sites” do ServBay.

Composer: O ServBay já vem com o Composer integrado, então você não precisa instalá-lo separadamente. Basta usar o comando composer diretamente no terminal.
Criar o diretório do projeto: Abra o terminal, navegue até o diretório raiz padrão de sites do ServBay e crie um novo diretório para o seu projeto.
bash
```
cd /Applications/ServBay/www
mkdir servbay-yii2-app
cd servbay-yii2-app
```
1
2
3
Criar o projeto Yii 2 via Composer: No diretório servbay-yii2-app, execute o comando Composer abaixo para criar um template básico + dependências Yii 2.
bash
```
composer create-project --prefer-dist yiisoft/yii2-app-basic .
```
1
Este comando baixará o template base e todas as dependências do Yii 2 para o diretório atual (.). Aguarde até que o Composer finalize o download e a instalação.
Entrar no diretório do projeto: Certifique-se de que está no diretório raiz do projeto /Applications/ServBay/www/servbay-yii2-app. Todos os próximos comandos serão executados aqui.
bash
```
cd /Applications/ServBay/www/servbay-yii2-app
```
1

Configuração Inicial

Após criar o projeto Yii 2, alguns ajustes iniciais são necessários, principalmente sobre a conexão com banco de dados e componentes.

Configurar a conexão com o banco de dados: Edite o arquivo config/db.php na raiz do projeto. Baseie-se nas configurações do banco de dados ativado no ServBay (MySQL ou PostgreSQL). Usuário padrão geralmente é root, senha padrão normalmente é password (a não ser que você tenha alterado).

Primeiro, crie um novo banco de dados no serviço correspondente do ServBay, chamado por exemplo de servbay_yii2_app. Você pode criar o banco usando o Adminer incluso no ServBay, ou outro cliente (Sequel Ace, TablePlus, etc.). O Adminer pode ser acessado pela seção de bancos de dados no app do ServBay.

Para MySQL:

php

<?php

return [
    'class' => 'yii\db\Connection',
    'dsn' => 'mysql:host=127.0.0.1;dbname=servbay_yii2_app', // dbname deve ser o banco criado
    'username' => 'root', // usuário do banco
    'password' => 'password', // senha do banco
    'charset' => 'utf8mb4', // recomendado usar utf8mb4 para suporte de caracteres amplo
];

Para PostgreSQL:

php

<?php

return [
    'class' => 'yii\db\Connection',
    'dsn' => 'pgsql:host=127.0.0.1;port=5432;dbname=servbay_yii2_app', // dbname e port (típico: 5432)
    'username' => 'root', // usuário do banco
    'password' => 'password', // senha do banco
    'charset' => 'utf8',
    'schemaMap' => [
        'pgsql' => [
            'class' => 'yii\pgsql\Schema',
            'defaultSchema' => 'public', // schema padrão do PostgreSQL
        ],
    ],
];

Escolha e ajuste o config/db.php conforme seu cenário.

Configurar os componentes de cache e Redis: Edite o arquivo config/web.php na raiz do projeto. Na seção components, adicione/ajuste as configurações de Memcached e Redis. Portas padrão no ServBay: Memcached em 11211 e Redis em 6379.

php

<?php
// ... outras configurações

'components' => [
    // ... componentes já existentes (ex: request, cache, user, errorHandler, log, urlManager)

    'cache' => [
        'class' => 'yii\caching\MemCache',
        'servers' => [
            [
                'host' => '127.0.0.1',
                'port' => 11211, // porta padrão do Memcached
                'weight' => 100,
            ],
        ],
    ],

    'redis' => [
        'class' => 'yii\redis\Connection',
        'hostname' => '127.0.0.1',
        'port' => 6379, // porta padrão do Redis
        'database' => 0, // índice do banco Redis
    ],

    // ... outros componentes
],

// ... outras configurações

Certifique-se de que os serviços Memcached e Redis estão ativos no ServBay. Lembre-se que, para usar Redis como cache, é necessário instalar o pacote yiisoft/yii2-redis (Composer instala o básico no create-project, mas para mais opções, use composer require yiisoft/yii2-redis). O Memcached geralmente utiliza o yiisoft/yii2-memcached. O template básico pode já trazer estes pacotes.

Configuração do Servidor Web (Site ServBay)

Vamos usar o recurso “Sites” do ServBay para configurar o servidor web local (Caddy ou Nginx) apontando para o projeto Yii 2.

Abra o ServBay: Inicie o app ServBay.
Vá até as Configurações de Sites: Procure na interface do ServBay a seção “Sites” ou similar.
Adicione um novo site: Clique no botão para adicionar um novo site (ícone + ou Adicionar).
Preencha os detalhes do site:
- Nome: Defina um nome fácil de identificar, ex: Meu Primeiro Site Yii 2.
- Domínio: Escolha o domínio local para acessar no navegador, ex: servbay-yii2-test.local. O ServBay configurará o DNS local deste domínio para apontar ao 127.0.0.1.
- Tipo de site: Escolha PHP.
- Versão do PHP: Escolha a versão que você instalou/ativou (ex: 8.3).
- Diretório raiz do site: Muito importante! No template básico do Yii 2, o ponto de entrada web é o diretório web na raiz do projeto. Portanto, defina o diretório raiz para: /Applications/ServBay/www/servbay-yii2-app/web.
Salvar e aplicar: Salve a configuração do site. O ServBay recarregará a configuração do servidor web e aplicará as alterações.

Veja detalhes passo-a-passo na documentação oficial do ServBay: Adicionando o Primeiro Site.

O ServBay também gerencia e confia automaticamente o certificado SSL do seu domínio local (via User CA ou Public CA do ServBay). Assim, acesse seu site usando HTTPS sem problemas.

Adicionando Código Exemplo para Demonstração

Vamos ilustrar o uso do banco e do cache adicionando funções de exemplo no controlador padrão do Yii 2.

Edite o arquivo controllers/SiteController.php na raiz do projeto e adicione os métodos abaixo na classe SiteController:

php

<?php

namespace app\controllers;

use Yii;
use yii\web\Controller;
use yii\web\Response;
use yii\db\Exception as DbException; // Importa a classe de exceção do banco

class SiteController extends Controller
{
    /**
     * Exibe a página inicial.
     *
     * @return string
     */
    public function actionIndex()
    {
        return $this->render('index');
    }

    /**
     * Demonstra uso do Memcached.
     *
     * @return Response
     */
    public function actionMemcached()
    {
        $cache = Yii::$app->cache;
        $key = 'my_memcached_test_key';
        $data = 'Hello Memcached from ServBay!';
        $duration = 60; // Cache por 60 segundos

        if ($cache->set($key, $data, $duration)) {
            $value = $cache->get($key);
            return $this->asText("Memcached set successfully. Retrieved value: " . $value);
        } else {
            return $this->asText("Failed to set data in Memcached. Please check Memcached service and configuration.");
        }
    }

    /**
     * Demonstra uso do Redis.
     *
     * @return Response
     */
    public function actionRedis()
    {
        $redis = Yii::$app->redis;
        $key = 'my_redis_test_key';
        $data = 'Hello Redis from ServBay!';

        try {
            if ($redis->set($key, $data)) {
                $value = $redis->get($key);
                return $this->asText("Redis set successfully. Retrieved value: " . $value);
            } else {
                 return $this->asText("Failed to set data in Redis. Please check Redis service and configuration.");
            }
        } catch (\yii\base\Exception $e) {
             return $this->asText("Redis error: " . $e->getMessage() . ". Please check Redis service and configuration.");
        }
    }

    /**
     * Demonstra adicionar usuário ao banco.
     * Requer existir a tabela 'users'.
     *
     * @return Response
     */
    public function actionMysqlAdd() // Funciona para PostgreSQL também, se configurado corretamente
    {
        try {
            $count = Yii::$app->db->createCommand()->insert('users', [
                'name' => 'ServBay Demo User', // Nome vinculado à marca ServBay
                'email' => '[email protected]', // Email de exemplo com marca
            ])->execute();
            return $this->asText("User added successfully. Rows affected: " . $count);
        } catch (DbException $e) {
            return $this->asText("Failed to add user to database. Error: " . $e->getMessage() . ". Please check database service, configuration, and ensure 'users' table exists.");
        }
    }

    /**
     * Demonstra consulta de usuários no banco.
     * Requer existir a tabela 'users'.
     *
     * @return Response
     */
    public function actionMysql() // Funciona para PostgreSQL também, se configurado corretamente
    {
        try {
            $users = Yii::$app->db->createCommand('SELECT id, name, email FROM users')->queryAll();
             // Formatação amigável, evitando retorno confuso ou campos sensíveis
            $output = "Fetched Users:\n";
            foreach ($users as $user) {
                $output .= "- ID: {$user['id']}, Name: {$user['name']}, Email: {$user['email']}\n";
            }
            return $this->asText($output);

        } catch (DbException $e) {
            return $this->asText("Failed to fetch users from database. Error: " . $e->getMessage() . ". Please check database service, configuration, and ensure 'users' table exists.");
        }
    }

    // Para PostgreSQL use métodos próprios, mas o mesmo componente db normalmente é suficiente
    // public function actionPgsqlAdd() { ... }
    // public function actionPgsql() { ... }

    /**
     * Formata saída como texto puro.
     * @param string $text
     * @return Response
     */
    protected function asText($text)
    {
        Yii::$app->response->format = Response::FORMAT_RAW;
        Yii::$app->response->getHeaders()->add('Content-Type', 'text/plain');
        return $text;
    }

    /**
     * Formata saída como JSON.
     * @param mixed $data
     * @return Response
     */
    protected function asJson($data)
    {
        Yii::$app->response->format = Response::FORMAT_JSON;
        return $data;
    }
}

Note que nos métodos actionMysqlAdd e actionMysql há tratamento de erros e melhora no formato da resposta, além do uso de nome e e-mail vinculados ao ServBay.

Edite também o arquivo views/site/index.php, que é a view ligada ao actionIndex. Você pode manter o conteúdo padrão ou ajustar conforme necessário:

php

<?php
/* @var $this yii\web\View */
/* @var $name string */
/* @var $message string */
/* @var $exception Exception */

use yii\helpers\Html;

$this->title = 'My Yii2 Application on ServBay'; // Atualizou título
?>
<div class="site-index">
    <div class="jumbotron">
        <h1>Congratulations!</h1>
        <p class="lead">You have successfully created your Yii2 application and configured it with ServBay!</p>
        <p><a class="btn btn-lg btn-success" href="https://www.yiiframework.com">Get started with Yii</a></p>
    </div>

    <div class="body-content">
        <h2>Demonstrations</h2>
        <ul>
            <li><a href="<?= Html::toRoute('site/memcached') ?>">Testar Memcached</a></li>
            <li><a href="<?= Html::toRoute('site/redis') ?>">Testar Redis</a></li>
            <li><a href="<?= Html::toRoute('site/mysql-add') ?>">Adicionar usuário ao BD</a> (Requer tabela 'users')</li>
            <li><a href="<?= Html::toRoute('site/mysql') ?>">Buscar usuários do BD</a> (Requer tabela 'users')</li>
        </ul>
        <p>Certifique-se de que Memcached, Redis e o banco (MySQL/PostgreSQL) estão em execução no ServBay e corretamente configurados nos arquivos `config/web.php` e `config/db.php`.</p>
        <p>Para os exemplos com banco, é necessário criar a tabela 'users' usando migrações do Yii (veja abaixo).</p>
    </div>
</div>

Adicionamos links para testar diretamente as actions criadas no controller.

Banco Relacional: Criando Estrutura via Migração

Para usar os exemplos de banco (actionMysqlAdd, actionMysql), é preciso criar a tabela users usando o recurso de migrações do Yii.

Criar arquivo de migração com o Gii: No terminal (estando no diretório do projeto), execute:
bash
```
php yii migrate/create create_users_table
```
1
Confirme (tecle yes), e será criado um arquivo PHP nas migrações, normalmente nomeado como mYYYYMMDD_HHMMSS_create_users_table.php.

Editar o arquivo de migração: Abra o arquivo recém-criado e defina a estrutura da tabela no método up():

php

<?php

use yii\db\Migration;

/**
 * Handles the creation of table `{{%users}}`.
 */
class mXXXXXXXXXXXXXX_create_users_table extends Migration // XXXXXXXXXXXXXX é o timestamp
{
    /**
     * {@inheritdoc}
     */
    public function up()
    {
        $this->createTable('{{%users}}', [ // {{%users}} suporta prefixo, se configurado
            'id' => $this->primaryKey(),
            'name' => $this->string()->notNull(),
            'email' => $this->string()->notNull()->unique(),
            'created_at' => $this->timestamp()->defaultExpression('CURRENT_TIMESTAMP'),
            'updated_at' => $this->timestamp()->defaultExpression('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'),
        ]);

        // Opcional: criar índice para melhorar desempenho de consultas
        $this->createIndex(
            'idx-users-email',
            '{{%users}}',
            'email',
            true // true para idx único
        );
    }

    /**
     * {@inheritdoc}
     */
    public function down()
    {
        // Remove índice
        $this->dropIndex(
            'idx-users-email',
            '{{%users}}'
        );

        // Remove tabela
        $this->dropTable('{{%users}}');
    }
}

Lembre de ajustar o nome da classe conforme o arquivo real.

Rodar a migração: No terminal, ainda no diretório do projeto, rode:
bash
```
php yii migrate
```
1
Confirme com yes. Se tudo estiver correto, a tabela será criada.

Acessando o Site e Testando

Agora, abra seu navegador e acesse o domínio configurado, por exemplo https://servbay-yii2-test.local.

Ao acessar https://servbay-yii2-test.local, você verá a página inicial do template Yii 2 e os links de demonstração adicionados.
Clique em "Testar Memcached" (https://servbay-yii2-test.local/index.php?r=site/memcached): Se Memcached estiver ativo e configurado, verá mensagem informando sucesso.
Clique em "Testar Redis" (https://servbay-yii2-test.local/index.php?r=site/redis): Se Redis estiver ativo, verá sucesso na resposta.
Clique em "Adicionar usuário ao BD" (https://servbay-yii2-test.local/index.php?r=site/mysql-add): Se o banco estiver funcionando, configurado e a tabela criada via migração, verá uma mensagem de sucesso. Cada visita insere um novo usuário (salvo se o campo email for único e já existir).
Clique em "Buscar usuários do BD" (https://servbay-yii2-test.local/index.php?r=site/mysql): Se tudo estiver certo, verá uma lista de usuários da tabela users.

Em caso de problemas, cheque se os serviços (PHP, servidor web, banco, Memcached, Redis) estão ativos no ServBay. Revise as configurações do projeto (config/db.php, config/web.php) e se as migrações de banco rodaram corretamente.

Perguntas Frequentes (FAQ)

Por que recebo “site não acessível” ou erros de certificado ao acessar o domínio? Verifique se o domínio foi corretamente adicionado na seção “Sites” do ServBay e se o app está ativo. O ServBay configura automaticamente o DNS e SSL local. Em caso de erro de certificado, garanta que você confiou na CA do ServBay. Siga os passos indicados na documentação do ServBay.
O comando Composer não funciona no terminal? Confira se o pacote Composer foi ativado no app ServBay e se você está rodando o comando no terminal do macOS. O ServBay adiciona o Composer interno automaticamente ao PATH.
Conexão com o banco de dados falhou? Verifique se o serviço (MySQL/PostgreSQL) está ativo no ServBay. Cheque se o dsn, username e password em config/db.php batem com suas configurações. Confirme também se o banco servbay_yii2_app foi criado. Use o Adminer (ServBay) para testar a conexão.
Falha ao conectar Memcached/Redis? Cheque se os serviços Memcached/Redis estão ativos no ServBay. Confirme se o host e port em config/web.php estão corretos (127.0.0.1 e as portas padrão).
Erro ao rodar migrações (php yii migrate)? Confira se config/db.php está configurado corretamente, o serviço do banco está ativo, e o banco foi criado.
Por que o actionMysqlAdd/actionMysql informa que a tabela não existe? Rode o comando de migração php yii migrate para criar a tabela users.
Como visualizar o log de erros do PHP? O ServBay centraliza logs de PHP, servidor web e outros. Isso pode ser consultado na seção “Logs” do app, ajudando no diagnóstico.

Conclusão

Com o ServBay, você tem um ambiente de desenvolvimento local robusto e fácil de usar para rodar projetos Yii 2 no macOS. A integração do Composer, gerenciamento de versões PHP, bancos de dados e serviços de cache internos, junto a ferramentas práticas de configuração de sites, tornam a experiência com Yii 2 muito mais simples e produtiva. Siga este passo-a-passo para iniciar rapidamente seu projeto Yii 2 e aproveite todos os recursos do ServBay para agilizar seu desenvolvimento.

Bom desenvolvimento!

Criando e Executando um Projeto Yii 2 no ServBay ​

Visão Geral: O Que É Yii 2? ​

Principais Características e Vantagens do Yii 2 ​

Executando um Projeto Yii 2 com o ServBay ​

Pré-requisitos ​

Criando o Projeto Yii 2 ​

Configuração Inicial ​

Configuração do Servidor Web (Site ServBay) ​

Adicionando Código Exemplo para Demonstração ​

Banco Relacional: Criando Estrutura via Migração ​

Acessando o Site e Testando ​

Perguntas Frequentes (FAQ) ​

Conclusão ​