Criando e Executando um Projeto Slim no ServBay

Este guia mostra como criar, configurar e executar rapidamente um projeto baseado no Slim Framework PHP usando o ServBay, uma poderosa plataforma local para desenvolvimento web. O ServBay oferece pacotes integrados de PHP, servidores web (Caddy/Nginx/Apache) e diversos bancos de dados, tornando-se o ambiente ideal para desenvolvimento com Slim.

O que é o Slim?

O Slim é um microframework PHP leve, projetado para criar aplicações web e APIs de forma simples e eficiente. Ele entrega recursos essenciais de roteamento e manipulação de requisições/respostas, sendo ótimo para projetos que demandam agilidade e também como base para aplicações mais robustas.

Principais características e vantagens do Slim

Leveza: O núcleo do Slim Framework é pequeno, consome poucos recursos e inicia rapidamente, sendo perfeito para aplicações pequenas, médias ou microsserviços.
Flexibilidade: Projetado para ser plugável, o Slim se integra facilmente a qualquer componente ou biblioteca de terceiros (como motores de template, ORM, autenticação etc.), oferecendo liberdade total para escolher as ferramentas mais adequadas ao seu projeto.
Facilidade de uso: Sua API enxuta e a documentação clara permitem que desenvolvedores entendam os conceitos nucleares e comecem a usar rapidamente.
Roteamento poderoso: Suporta múltiplos métodos HTTP (GET, POST, PUT, DELETE e outros) e configuração de rotas avançada, incluindo grupos de rotas, middlewares e captura de parâmetros.
Suporte a middlewares: A camada de middlewares do Slim permite executar tarefas (como autenticação, logging, tratamento de CORS etc.) antes que a requisição chegue à lógica do app ou antes que a resposta seja enviada ao cliente.

O Slim é excelente para construir APIs RESTful, prototipagem ágil e para funcionalidades pontuais e independentes.

Criando e Executando um Projeto Slim com o ServBay

Neste tutorial, utilizaremos o ambiente PHP pré-configurado do ServBay e a funcionalidade de Sites para configurar o servidor web e disponibilizar o projeto Slim com configuração mínima.

Pré-requisitos

Antes de começar, garanta que:

O ServBay está instalado e em execução: Certifique-se de que o ServBay já está instalado no seu macOS e rodando.
O ServBay possui Composer integrado: O Composer vem integrado por padrão no ServBay; não é necessário instalar separadamente.

Criando o Projeto Slim

O ServBay recomenda manter os projetos de site em /Applications/ServBay/www para facilitar o gerenciamento e configuração.

Acesse o diretório raiz dos sites do ServBay:
bash
```
cd /Applications/ServBay/www
```
1
Crie o diretório do projeto: Crie um novo diretório para seu projeto Slim.
bash
```
mkdir servbay-slim-app
```
1
Entre no diretório do projeto:
bash
```
cd servbay-slim-app
```
1
Instale o Slim com Composer: No diretório do projeto, use o Composer para instalar o Slim e sua implementação PSR-7.
bash
```
composer require slim/slim "^4.0" slim/psr7 -W
```
1
Este comando irá baixar o Slim Framework e a biblioteca slim/psr7 para o diretório vendor do projeto e criar os arquivos composer.json e composer.lock.

Inicializando a Aplicação Slim

Crie o arquivo de entrada: Projetos Slim geralmente usam um único arquivo de entrada (ex: public/index.php) para lidar com todas as requisições. Na raiz do projeto, crie o diretório public e, dentro dele, o arquivo index.php.
bash
```
mkdir public
touch public/index.php
```
1
2

Edite o arquivo de entrada: Abra o arquivo public/index.php e adicione o seguinte código base para o Slim:

php

<?php
// Carrega o autoload do Composer
require __DIR__ . '/../vendor/autoload.php';

// Importa as interfaces PSR-7 e a fábrica Slim necessárias
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

// Cria uma instância da aplicação Slim
$app = AppFactory::create();

// Adiciona uma rota básica para requisições GET na raiz '/'
$app->get('/', function (Request $request, Response $response, $args) {
    // Escreve conteúdo na resposta
    $response->getBody()->write("Hello ServBay!");
    // Retorna o objeto de resposta
    return $response;
});

// Executa a aplicação Slim
$app->run();

Esse exemplo configura o Slim para responder à URL raiz (/) com o texto "Hello ServBay!".

Configurando o Site no ServBay

Para acessar seu projeto Slim pelo navegador, você precisa cadastrar um Site no ServBay (anteriormente chamado de "Host").

Abra a interface do ServBay.
Vá para o módulo de Sites.
Clique para adicionar um novo site.
Preencha as informações conforme o seu projeto:
- Nome: My First Slim Dev Site (ou outro nome de sua preferência)
- Domínio: servbay-slim-test.local (recomenda-se usar .local ou .test para desenvolvimento local)
- Tipo do Site: PHP
- Versão do PHP: Escolha a versão desejada, por exemplo, 8.3.
- Diretório Raiz (Document Root): Aponte para o diretório public do seu projeto: /Applications/ServBay/www/servbay-slim-app/public (pois o arquivo index.php de entrada do Slim está ali, e o servidor web deve apontar para essa pasta).
Salve o site. O ServBay atualizará automaticamente a configuração do servidor web.

Para um tutorial detalhado, consulte Adicionando o Primeiro Site.

Acessando o Seu Site Slim

Após a configuração, abra o navegador e acesse https://servbay-slim-test.local.

Se tudo estiver correto, você verá na página a mensagem Hello ServBay!, indicando que seu projeto Slim está rodando pelo servidor web do ServBay.

Exemplos de Integração com Banco de Dados

O Slim não vem com camada de abstração de banco de dados por padrão, mas pode ser facilmente integrado a diversas bibliotecas PHP. Aqui, usaremos o Eloquent ORM do Laravel (via componente illuminate/database) para exemplificar a integração com MySQL e PostgreSQL, além de mostrar exemplos com Memcached e Redis.

Pré-requisito: Criando o Banco e Executando Migrations

Antes da integração, crie o banco de dados no ServBay e defina a estrutura das tabelas do app.

Criando o banco de dados:
- Acesse o aplicativo ServBay, navegue até o pacote do banco de dados (ex: MySQL ou PostgreSQL).
- Use as ferramentas fornecidas (phpMyAdmin para MySQL/MariaDB, pgAdmin para PostgreSQL) ou o cliente de linha de comando para criar um novo banco, por exemplo, servbay_slim_app.
- A senha padrão do usuário root normalmente é password. Você pode checar ou alterar isso pela interface do ServBay.

Instalando e configurando o Phinx (ferramenta de migrations): Phinx ajuda no versionamento da estrutura do banco.

No diretório /Applications/ServBay/www/servbay-slim-app, instale o Phinx:
bash
```
composer require robmorgan/phinx
```
1

Inicialize a configuração do Phinx:

bash

vendor/bin/phinx init

Isso criará o arquivo phinx.yml na raiz do projeto. Edite-o para configurar a conexão com seu banco, exemplo:

yaml

paths:
    migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
    seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'

environments:
    default_migration_table: phinxlog
    default_environment: development # Ou o nome do seu ambiente

    development: # Configure conforme seu banco
        adapter: mysql # Ou pgsql
        host: 127.0.0.1
        name: servbay_slim_app # Nome do banco criado por você
        user: root
        pass: password # Senha do banco
        port: 3306 # MySQL padrão, PostgreSQL = 5432
        charset: utf8mb4 # Recomendado para MySQL
        collation: utf8mb4_unicode_ci # Recomendado para MySQL

version_order: creation

Crie o arquivo de migration: Use o Phinx para criar a migration.

bash

vendor/bin/phinx create CreateUsersTable

Isso criará um novo PHP em db/migrations. Edite o método change() para definir a tabela users:

php

<?php

declare(strict_types=1);

use Phinx\Migration\AbstractMigration;

final class CreateUsersTable extends AbstractMigration
{
    /**
     * Método change.
     *
     * Use este método para migrations reversíveis.
     *
     * Mais informações sobre migrations: 
     * https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
     *
     * Lembre-se: use "create()" ou "update()" e NÃO "save()" com a classe Table.
     */
    public function change(): void
    {
        $table = $this->table('users');
        $table->addColumn('name', 'string')
              ->addColumn('email', 'string', ['unique' => true])
              ->addTimestamps() // Adiciona os campos created_at e updated_at
              ->create();
    }
}

Execute a migration: No diretório do projeto, rode o comando Phinx para criar a tabela users.
bash
```
vendor/bin/phinx migrate
```
1
Importante: Finalize a criação do banco e das migrations antes de executar os exemplos seguintes.

Usando o Componente illuminate/database

Vamos utilizar o componente de banco do Laravel (illuminate/database) como ORM/builder.

Instale o illuminate/database: No diretório /Applications/ServBay/www/servbay-slim-app:
bash
```
composer require illuminate/database
```
1

Configure a conexão no public/index.php: Logo após o require __DIR__ . '/../vendor/autoload.php'; e antes do $app = AppFactory::create();, adicione:

php

// ... outros require e use ...

use Illuminate\Database\Capsule\Manager as Capsule; // Importa o Capsule

// Inicializa o Eloquent ORM
$capsule = new Capsule;

// Adiciona configuração do banco (ajuste driver e demais conforme seu caso)
$capsule->addConnection([
    'driver' => 'mysql', // Ou 'pgsql'
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app', // Nome do banco
    'username' => 'root', // Usuário
    'password' => 'password', // Senha
    'charset' => 'utf8mb4', // Recomendado para MySQL
    'collation' => 'utf8mb4_unicode_ci', // Recomendado para MySQL
    'prefix' => '',
    // No PostgreSQL, adicione:
    // 'schema' => 'public',
]);

// Torna global
$capsule->setAsGlobal();

// Inicia Eloquent
$capsule->bootEloquent();

// ... crie o $app = AppFactory::create(); ...

Exemplo com MySQL

Supondo que o pacote MySQL está ativo no ServBay, o banco servbay_slim_app existe e a tabela users foi criada via Phinx:

No public/index.php, antes do $app->run();, adicione estas rotas:

php

// ... código de setup e rota '/' ...

use Illuminate\Database\Capsule\Manager as Capsule; // Certifique-se do import

// Rota para adicionar dado de usuário
$app->get('/mysql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay Demo User',
            'email' => 'servbay-demo-' . time() . '@servbay.test', // email único com time()
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500); // Código de erro
    }
    return $response;
});

// Rota para buscar dados de usuários
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // Salva JSON
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Acesse:

https://servbay-slim-test.local/mysql-add-user para adicionar um usuário.
https://servbay-slim-test.local/mysql-get-users para listar todos usuários em JSON.

Exemplo com PostgreSQL

Para PostgreSQL, com o banco criado e as migrations feitas, no public/index.php ajuste o driver para 'pgsql' e inclua o parâmetro schema:

php

$capsule->addConnection([
    'driver' => 'pgsql', // Use pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // Geralmente para PostgreSQL
    'prefix' => '',
    'schema' => 'public', // Necessário no PostgreSQL
]);
// ... restante igual ...

Adicione estas rotas ao public/index.php antes do $app->run();:

php

// ... inicialização e outras rotas ...

use Illuminate\Database\Capsule\Manager as Capsule; // Certifique-se do import

// Adiciona usuário
$app->get('/pgsql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay PG Demo User',
            'email' => 'servbay-pg-demo-' . time() . '@servbay.test', // para garantir email único
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('User added to PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Busca usuários
$app->get('/pgsql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson());
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Error fetching users: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Acesse:

https://servbay-slim-test.local/pgsql-add-user para adicionar usuário no PostgreSQL.
https://servbay-slim-test.local/pgsql-get-users para listar todos usuários.

Exemplo com Memcached

O ServBay traz o pacote Memcached e a extensão PHP ext-memcached. Basta instalar o cliente PHP. Usaremos memcached/memcached.

Instale o cliente Memcached: No diretório do projeto:
bash
```
composer require memcached/memcached
```
1

Adicione rota Memcached no public/index.php:

php

// ... setup e rotas anteriores ...

// Rota de exemplo com Memcached
$app->get('/memcached-example', function (Request $request, Response $response, $args) {
    // Cria instância do Memcached
    $memcached = new Memcached();
    // Adiciona servidor (padrão ServBay: 127.0.0.1:11211)
    $memcached->addServer('127.0.0.1', 11211);

    $cacheKey = 'my_servbay_cache_key';
    // Busca do cache
    $cachedData = $memcached->get($cacheKey);

    if ($cachedData === false) {
        // Não há no cache: cria e armazena
        $cachedData = 'Hello Memcached from ServBay! This was not cached.';
        $memcached->set($cacheKey, $cachedData, 60); // ttl 60s
        $response->getBody()->write($cachedData);
    } else {
        // Já está no cache
        $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
    }

    return $response;
});

// ... $app->run();

Acesse: https://servbay-slim-test.local/memcached-example
Na primeira visita: "This was not cached."
Nas demais (até expirar): "This was served from cache."

Exemplo com Redis

O ServBay fornece pacote Redis e extensão PHP ext-redis. O cliente PHP recomendado é o predis/predis.

Instale o cliente Redis: No diretório do projeto:
bash
```
composer require predis/predis
```
1

Adicione rota Redis no public/index.php:

php

// ... setup e outras rotas ...
// ... opcional: rota do Memcached ...

use Predis\Client as RedisClient; // Importa o Predis

// Rota de exemplo com Redis
$app->get('/redis-example', function (Request $request, Response $response, $args) {
    try {
        // Instancia Redis (ServBay padrão: 127.0.0.1:6379)
        $redis = new RedisClient([
            'scheme' => 'tcp',
            'host' => '127.0.0.1',
            'port' => 6379,
        ]);

        $cacheKey = 'my_servbay_redis_cache_key';
        // Busca do cache
        $cachedData = $redis->get($cacheKey);

        if ($cachedData === null) {
            // Não há no cache: cria e armazena
            $cachedData = 'Hello Redis from ServBay! This was not cached.';
            $redis->setex($cacheKey, 60, $cachedData); // expira em 60s
            $response->getBody()->write($cachedData);
        } else {
            // Já está no cache
            $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
        }
    } catch (\Exception $e) {
        // Captura exceções de conexão ou operação
        $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }

    return $response;
});

// ... $app->run();

Acesse: https://servbay-slim-test.local/redis-example
Primeira vez: "This was not cached."
Seguintes (até expirar cache): "This was served from cache."

Conclusão

Seguindo estes passos, você criou com sucesso um projeto Slim Framework no ambiente local fornecido pelo ServBay e configurou a funcionalidade de Sites para hospedar e acessar o projeto. Também aprendeu a integrar vários pacotes do ServBay (como MySQL, PostgreSQL, Memcached, Redis) e as respectivas extensões PHP, adicionando recursos de banco de dados e cache na sua aplicação Slim. O ServBay simplifica a configuração e o gerenciamento do ambiente local, permitindo que você foque no desenvolvimento do seu app Slim.

Criando e Executando um Projeto Slim no ServBay ​

O que é o Slim? ​

Principais características e vantagens do Slim ​

Criando e Executando um Projeto Slim com o ServBay ​

Pré-requisitos ​

Criando o Projeto Slim ​

Inicializando a Aplicação Slim ​

Configurando o Site no ServBay ​

Acessando o Seu Site Slim ​

Exemplos de Integração com Banco de Dados ​

Pré-requisito: Criando o Banco e Executando Migrations ​

Usando o Componente illuminate/database ​

Exemplo com MySQL ​

Exemplo com PostgreSQL ​

Exemplo com Memcached ​

Exemplo com Redis ​

Conclusão ​