Criando e Executando um Projeto Slim no ServBay

Neste guia, você vai aprender como criar, configurar e executar rapidamente um projeto baseando-se no Slim Framework PHP utilizando o ServBay — um ambiente de desenvolvimento web local robusto e integrado. O ServBay fornece pacotes integrados de PHP, servidores web (Caddy/Nginx/Apache) e múltiplos bancos de dados, tornando-se a plataforma ideal para o desenvolvimento com Slim.

O que é Slim?

Slim é um microframework PHP leve, projetado para criar rapidamente aplicações web e APIs simples, mas com recursos poderosos. Ele oferece funcionalidades essenciais como roteamento, manipulação de requisições e respostas, sendo perfeito para projetos que requerem desenvolvimento e implantação ágeis, bem como uma base sólida para aplicações mais complexas.

Principais recursos e vantagens do Slim

Leveza: O núcleo do Slim é extremamente compacto, consumindo poucos recursos e com inicialização rápida, ideal para aplicações pequenas e médias ou microserviços.
Flexibilidade: Projetado para ser plugável, o Slim integra facilmente qualquer componente ou biblioteca de terceiros (como motores de template, ORM, autenticação, etc.), oferecendo liberdade para usar a melhor solução para cada necessidade do seu projeto.
Fácil de usar: Com uma API clara e documentação objetiva, desenvolvedores conseguem dominar rapidamente os conceitos e partir para a prática.
Roteamento eficiente: Suporte a múltiplos métodos HTTP (GET, POST, PUT, DELETE, entre outros) e configuração avançada de rotas, incluindo grupos, middlewares e captura de parâmetros.
Suporte a Middleware: O mecanismo de middlewares permite executar tarefas antes ou depois da lógica de aplicação, tais como autenticação, logging, tratamento de CORS, etc.

Slim é especialmente indicado para construção de APIs RESTful, desenvolvimento rápido de protótipos e funcionalidades específicas e independentes.

Criando e Executando um Projeto Slim no ServBay

Este tutorial utiliza o ambiente PHP pré-configurado do ServBay e o recurso de Sites para configurar o servidor web, facilitando o acesso à sua aplicação Slim por meio de ajustes simples.

Pré-requisitos

Antes de começar, garanta que:

ServBay instalado e em execução: Certifique-se de que o ServBay está devidamente instalado no seu macOS ou Windows, e que o aplicativo está rodando.
Composer integrado ao ServBay: O ServBay já vem com Composer integrado, não há necessidade de instalação separada.

Criando seu Projeto Slim

A recomendação do ServBay é organizar todos os projetos web no seguinte diretório, facilitando o gerenciamento via ServBay:

macOS: /Applications/ServBay/www
Windows: C:\ServBay\www

Acesse o diretório root do ServBay:
macOS:
bash
```
cd /Applications/ServBay/www
```
1
Windows:
cmd
```
cd C:\ServBay\www
```
1
Crie o diretório do seu projeto: Faça um novo diretório para armazenar seu projeto Slim.
bash
```
mkdir servbay-slim-app
```
1
Acesse a pasta do projeto:
bash
```
cd servbay-slim-app
```
1
Instale o Slim via Composer: Dentro da pasta do projeto, utilize o Composer para instalar o Slim e sua implementação PSR-7.
bash
```
composer require slim/slim "^4.0" slim/psr7 -W
```
1
Esse comando irá baixar o Slim Framework e a biblioteca slim/psr7 para a pasta vendor, além de gerar os arquivos composer.json e composer.lock.

Inicializando o aplicativo Slim

Crie o arquivo de entrada: Normalmente, aplicativos Slim usam um único arquivo de entrada (por exemplo, public/index.php) para processar todas as requisições. No root do projeto, crie a pasta public e o arquivo index.php dentro dela.
bash
```
mkdir public
touch public/index.php
```
1
2

Edite o arquivo de entrada: Abra o public/index.php e adicione o seguinte código básico do Slim:

php

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

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

// Cria a instância do aplicativo Slim
$app = AppFactory::create();

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

// Executa o aplicativo Slim
$app->run();

Este trecho configura o aplicativo Slim mais simples possível, definindo uma rota para requisições GET à URL raiz (/), que retorna o texto "Hello ServBay!".

Configurando o site no ServBay

Para acessar sua aplicação Slim pelo navegador, você precisa configurar um site no ServBay (anteriormente chamado de “Host”).

Abra o aplicativo ServBay.
Navegue até o módulo Sites (Websites).
Clique para adicionar um novo site.
Preencha os campos conforme seu projeto:
- Nome: My First Slim Dev Site (ou qualquer nome que desejar)
- Domínio: servbay-slim-test.local (sugere-se usar domínios terminando em .local ou .test para desenvolvimento)
- Tipo de site: PHP
- Versão do PHP: Escolha a versão desejada, por exemplo, 8.3.
- Root do documento: Selecione a pasta public do seu projeto:
  - macOS: /Applications/ServBay/www/servbay-slim-app/public
  - Windows: C:\ServBay\www\servbay-slim-app\public
  Isso é necessário porque o arquivo de entrada do Slim, index.php, está na pasta public, e o servidor web deve apontar para esse diretório.
Salve a configuração do site. O ServBay irá atualizar automaticamente as configurações do servidor web.

Para um passo a passo detalhado, consulte Como adicionar o primeiro site.

Acessando seu site Slim

Após a configuração, abra seu navegador e visite o domínio configurado https://servbay-slim-test.local.

Se tudo estiver correto, a página mostrará o texto Hello ServBay!, indicando que seu projeto Slim está rodando corretamente no servidor do ServBay.

Exemplos de Integração com Banco de Dados

O Slim Framework não fornece uma camada de abstração de banco de dados por padrão, mas você pode integrá-lo facilmente com diversas bibliotecas PHP. A seguir, mostramos como conectar MySQL e PostgreSQL utilizando o ORM Eloquent do Laravel (via componente illuminate/database), além de exemplos com Memcached e Redis.

Pré-requisito: Criação do banco e execução de migrações

Antes de integrar banco de dados, é necessário criar o banco desejado no ServBay e definir as tabelas necessárias para sua aplicação.

Crie o banco de dados:
- Abra o aplicativo ServBay, navegue até o pacote de banco escolhido (MySQL ou PostgreSQL).
- Usando as ferramentas de gerenciamento do ServBay (phpMyAdmin para MySQL/MariaDB, pgAdmin para PostgreSQL) ou o cliente de linha de comando, crie um banco chamado, por exemplo, servbay_slim_app.
- A senha padrão do usuário root no ServBay geralmente é password, podendo ser conferida ou alterada na interface do ServBay.

Instale e configure o Phinx (ferramenta de migração): O Phinx é um dos principais gerenciadores de migração PHP para controle de versão do banco.

Instale o Phinx via Composer na raiz do projeto:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require robmorgan/phinx
```
1

Inicialize a configuração do Phinx:

bash

vendor/bin/phinx init

Isso irá criar o arquivo phinx.yml na raiz do projeto. Edite-o incluindo sua configuração de banco, por 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 ambiente desejado

    development: # ajuste conforme banco utilizado
        adapter: mysql # ou pgsql
        host: 127.0.0.1
        name: servbay_slim_app # nome do banco
        user: root
        pass: password # senha do banco
        port: 3306 # MySQL padrão, PostgreSQL padrão: 5432
        charset: utf8mb4
        collation: utf8mb4_unicode_ci

version_order: creation

Crie o arquivo de migração: Utilize o comando abaixo para criar a migração:

bash

vendor/bin/phinx create CreateUsersTable

Um novo arquivo PHP será criado na pasta 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.
     *
     * Escreva suas migrações reversíveis aqui.
     *
     * Mais informações: https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
     *
     * Lembre-se de usar "create()" ou "update()" e NÃO "save()" quando estiver
     * trabalhando 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 migração: Na raiz do projeto, execute o comando abaixo para criar a tabela users:
bash
```
vendor/bin/phinx migrate
```
1
Atenção: Antes de executar qualquer código relacionado ao banco de dados, conclua os passos de criação e migração do banco.

Usando o componente illuminate/database

Aqui utilizamos o componente ORM e query builder do Laravel (illuminate/database).

Instale o illuminate/database: Na pasta raiz do projeto:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require illuminate/database
```
1

Inicialize a conexão com o banco em public/index.php: Após require __DIR__ . '/../vendor/autoload.php';, antes de $app = AppFactory::create();, adicione:

php

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

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

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

// Configurações de conexão (ajuste o driver e parâmetros conforme o banco usado)
$capsule->addConnection([
    'driver' => 'mysql', // ou 'pgsql'
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8mb4', // recomendado para MySQL
    'collation' => 'utf8mb4_unicode_ci', // recomendado para MySQL
    'prefix' => '',
    // Para PostgreSQL, inclua o parâmetro schema
    // 'schema' => 'public',
]);

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

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

// ... cria a aplicação Slim ($app = AppFactory::create();) ...

Exemplo MySQL

Suponha que você já iniciou o pacote MySQL no ServBay, criou o banco servbay_slim_app e executou a migração para criar a tabela users.

Acrescente as rotas abaixo em public/index.php, antes de $app->run();:

php

// ... inicialização e rota '/' ...

use Illuminate\Database\Capsule\Manager as Capsule; // certifique-se de importar

// Rota para inserir 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', // garante 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 MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error adding user: ' . $e->getMessage());
        $response = $response->withStatus(500); // retorna erro
    }
    return $response;
});

// Rota para buscar usuários
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // converte resultado para JSON
        $response = $response->withHeader('Content-Type', 'application/json'); // define tipo de conteúdo
    } 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 novo usuário à tabela users.
https://servbay-slim-test.local/mysql-get-users para consultar os usuários e exibir os dados em JSON.

Exemplo PostgreSQL

Suponha que o pacote PostgreSQL está ativo, o banco servbay_slim_app foi criado e a tabela users definida via Phinx (confirme adapter e port como pgsql e 5432).

No arquivo de configuração de banco em public/index.php, altere driver para pgsql e inclua o parâmetro schema:

php

$capsule->addConnection([
    'driver' => 'pgsql', // agora pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // padrão no PostgreSQL
    'prefix' => '',
    'schema' => 'public',
]);
// ... as demais configurações continuam iguais ...

Adicione as seguintes rotas antes do $app->run();:

php

// ... inicialização, rota '/', rotas MySQL ...

use Illuminate\Database\Capsule\Manager as Capsule; // certifique-se de importar

// Rota para inserir usuário no PostgreSQL
$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',
            '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;
});

// Rota para buscar usuários no PostgreSQL
$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 inserir um usuário na tabela do PostgreSQL.
https://servbay-slim-test.local/pgsql-get-users para consultar todos os usuários em JSON.

Exemplo Memcached

O ServBay inclui o pacote Memcached e a extensão PHP ext-memcached. Só é necessário instalar um cliente PHP, como memcached/memcached.

Instale o cliente Memcached: Na raiz do projeto:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require memcached/memcached
```
1

Adicione as rotas para uso do Memcached: Antes do $app->run(); inclua:

php

// ... inicialização, rotas de banco de dados ...

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

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

    if ($cachedData === false) {
        // Se não tem cache, gera dados e armazena
        $cachedData = 'Hello Memcached from ServBay! This was not cached.';
        // Grava no cache, ttl de 60 segundos
        $memcached->set($cacheKey, $cachedData, 60);
        $response->getBody()->write($cachedData);
    } else {
        // Se tem cache, retorna dados do 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 verá "This was not cached.". Nas visitas seguintes (antes do cache expirar), veja "This was served from cache.".

Exemplo Redis

O ServBay inclui o pacote Redis e a extensão PHP ext-redis. Basta instalar um cliente como predis/predis.

Instale o cliente Redis: Na raiz do projeto:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require predis/predis
```
1

Adicione as rotas para uso do Redis: Antes do $app->run();:

php

// ... inicialização, rotas de banco, Memcached ...

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

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

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

        if ($cachedData === null) {
            // Se não tem cache, gera dados e armazena
            $cachedData = 'Hello Redis from ServBay! This was not cached.';
            // Grava com expiração de 60 segundos
            $redis->setex($cacheKey, 60, $cachedData);
            $response->getBody()->write($cachedData);
        } else {
            // Se tem cache, retorna dados do 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. Na primeira visita verá "This was not cached.". Nas visitas seguintes (antes do cache expirar), veja "This was served from cache.".

Conclusão

Após seguir os passos acima, você terá criado um projeto Slim Framework rodando no ambiente local do ServBay, utilizando o recurso de Sites para hospedagem e acesso. Também aprendeu como integrar bancos de dados MySQL, PostgreSQL, Memcached e Redis utilizando os pacotes e extensões disponíveis no ServBay. O ServBay simplifica a configuração e gestão do ambiente local, permitindo que você foque no desenvolvimento das funcionalidades do seu aplicativo Slim.

Criando e Executando um Projeto Slim no ServBay ​

O que é Slim? ​

Principais recursos e vantagens do Slim ​

Criando e Executando um Projeto Slim no ServBay ​

Pré-requisitos ​

Criando seu Projeto Slim ​

Inicializando o aplicativo Slim ​

Configurando o site no ServBay ​

Acessando seu site Slim ​

Exemplos de Integração com Banco de Dados ​

Pré-requisito: Criação do banco e execução de migrações ​

Usando o componente illuminate/database ​

Exemplo MySQL ​

Exemplo PostgreSQL ​

Exemplo Memcached ​

Exemplo Redis ​

Conclusão ​

Criando e Executando um Projeto Slim no ServBay

O que é Slim?

Principais recursos e vantagens do Slim

Criando e Executando um Projeto Slim no ServBay

Pré-requisitos

Criando seu Projeto Slim

Inicializando o aplicativo Slim

Configurando o site no ServBay

Acessando seu site Slim

Exemplos de Integração com Banco de Dados

Pré-requisito: Criação do banco e execução de migrações

Usando o componente illuminate/database

Exemplo MySQL

Exemplo PostgreSQL

Exemplo Memcached

Exemplo Redis

Conclusão