Creare ed eseguire un progetto PHPixie su macOS con ServBay

PHPixie è un framework PHP leggero e ad alte prestazioni, progettato per lo sviluppo rapido di applicazioni web. Segue il modello HMVC (Hierarchical Model-View-Controller), offrendo una struttura di codice pulita e capacità di elaborazione efficienti. PHPixie è apprezzato dagli sviluppatori per la sua semplicità, flessibilità e prestazioni elevate.

Caratteristiche principali e vantaggi di PHPixie

Leggerezza: Il core di PHPixie è molto essenziale, includendo solo i componenti necessari per costruire l'applicazione. Garantisce avvio ed esecuzione rapidi.
Alte prestazioni: Il design del framework è ottimizzato per l'efficienza e può gestire richieste concorrenti in maniera efficace, adatto quindi anche ad applicazioni esigenti in termini di performance.
Facile da apprendere: Fornisce API chiare e concise, accompagnate da una documentazione completa, così che gli sviluppatori possano familiarizzare rapidamente.
Flessibilità: La struttura del framework è poco vincolante e permette di scegliere ed integrare liberamente librerie e componenti di terze parti in base alle esigenze del progetto.
Comunità attiva: PHPixie vanta una comunità vivace che offre numerose estensioni e risorse di supporto.

PHPixie può aiutare gli sviluppatori a costruire applicazioni web di alta qualità e alte prestazioni, ideale sia per piccoli progetti che per soluzioni enterprise di grandi dimensioni.

Creazione ed esecuzione di un progetto PHPixie con ServBay

Questa guida ti mostrerà come utilizzare l'ambiente di sviluppo web locale fornito da ServBay per creare ed eseguire un progetto PHPixie. Useremo l’ambiente PHP integrato in ServBay, il gestore delle dipendenze Composer e la funzione “Siti Web” per configurare il server web, permettendo così un facile accesso locale oltre all’integrazione con database e sistemi di cache.

Prerequisiti

ServBay installato e in esecuzione su macOS. ServBay integra PHP, Composer, diversi database (MySQL, PostgreSQL, MongoDB, Redis, ecc.) e il server web Caddy.
Conoscenza basilare delle operazioni tramite linea di comando.

Creazione di un progetto PHPixie

Percorso consigliato per i siti web

ServBay consiglia di organizzare tutti i tuoi progetti web locali nella directory /Applications/ServBay/www, per una migliore gestione e un più semplice controllo dei permessi di accesso.

Verifica l'installazione di Composer: ServBay include Composer di default, quindi non è necessaria un'installazione aggiuntiva. Puoi aprire il terminale e digitare composer --version per verificare.
Crea la cartella del progetto: Nella directory radice consigliata da ServBay, crea una nuova cartella per il tuo progetto PHPixie e accedici:
bash
```
cd /Applications/ServBay/www
mkdir servbay-phpixie-app
cd servbay-phpixie-app
```
1
2
3
Crea il progetto PHPixie tramite Composer: All’interno della cartella del progetto, avvia il comando Composer per scaricare il template di PHPixie:
bash
```
composer create-project phpixie/project .
```
1
Composer scaricherà PHPixie e tutte le sue dipendenze nella directory corrente.

Configurazione del server web

Utilizza la funzione Siti Web di ServBay per configurare il server web Caddy in modo che punti correttamente al tuo progetto PHPixie.

Apri l’interfaccia di ServBay.
Vai all’elenco Siti Web (Websites).
Clicca su aggiungi un nuovo sito.
Inserisci le informazioni di configurazione:
- Nome: Ad esempio My First PHPixie Dev Site (usato internamente da ServBay).
- Dominio: Ad esempio servbay-phpixie-test.local (il dominio locale su cui accederai tramite browser).
- Tipo di sito: Seleziona PHP.
- Versione PHP: Scegli quella desiderata, ad esempio 8.3.
- Radice del sito (Document Root): Punta alla directory web del tuo progetto: /Applications/ServBay/www/servbay-phpixie-app/web.
Perché la directory /web?
Il file di ingresso del progetto PHPixie è web/index.php. Per motivi di sicurezza e best practice, la radice del server web dovrebbe puntare direttamente alla directory web che contiene questo file d’ingresso, evitando che file sensibili (come configurazioni o la cartella vendor) siano accessibili via web.
Salva la configurazione. ServBay configurerà automaticamente Caddy e aggiornerà, se necessario, il file hosts locale affinché servbay-phpixie-test.local punti al tuo server ServBay.

Per dettagli passo-passo consulta la guida Aggiungi il primo sito.

Aggiunta del codice di esempio

Per verificare che il progetto funzioni e per mostrare l’integrazione con database e sistemi di cache, aggiungeremo qualche esempio di codice.

Crea un controller di esempio: In src/App/HTTP/Controller/Home.php aggiungi il seguente codice. Se la cartella o il file non esistono, creali manualmente.

php

<?php

namespace App\HTTP\Controller;

use PHPixie\HTTP\Request;
use PHPixie\Template;
use PHPixie\Database\Query; // Importa la classe Query

class Home extends \PHPixie\Controller
{
    protected $template;

    public function __construct(Template $template)
    {
        $this->template = $template;
    }

    // action predefinita per la home page
    public function action_index(Request $request)
    {
        // Rendering del template assets/templates/app/home.php
        return $this->template->render('app:home');
    }

    // action di esempio per Memcached
    public function action_memcached(Request $request)
    {
        $cache = $this->components->cache();
        $cache->set('key', 'Hello Memcached from ServBay!', 60); // Salva dato, valido 60 secondi
        $value = $cache->get('key'); // Recupera dato
        return $this->response()->string($value); // Restituisce risposta come stringa
    }

    // action di esempio per Redis
    public function action_redis(Request $request)
    {
        $redis = $this->components->redis();
        $redis->set('key', 'Hello Redis from ServBay!'); // Salva dato
        $value = $redis->get('key'); // Recupera dato
        return $this->response()->string($value); // Restituisce risposta come stringa
    }

    // action per aggiungere utenti in MySQL/PostgreSQL
    public function action_add_user(Request $request)
    {
        // Ottieni il query builder dal componente database
        $query = $this->components->database()->query();
        // Inserisci un nuovo utente nella tabella 'users'
        $query->insert('users')->data([
            'name' => 'ServBay Demo User',
            'email' => 'demo-' . uniqid() . '@servbay.test', // Usa email univoca
        ])->execute(); // Esegui l'inserimento

        return $this->response()->string('User added successfully.'); // Restituisce conferma aggiunta
    }

    // action per elencare gli utenti da MySQL/PostgreSQL
    public function action_list_users(Request $request)
    {
        // Ottieni il query builder dal componente database
        $query = $this->components->database()->query();
        // Seleziona tutti gli utenti dalla tabella 'users'
        $users = $query->select('*')->from('users')->execute()->fetchAll(); // Recupera tutti i risultati

        return $this->response()->json($users); // Restituisce la lista utenti in formato JSON
    }
}

Crea il template di esempio: Aggiungi in assets/templates/app/home.php il seguente codice. Se la cartella o il file non esistono, creali manualmente.

php

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Welcome to PHPixie on ServBay</title>
    <style>
        body { font-family: sans-serif; line-height: 1.6; margin: 20px; }
        h1 { color: #333; }
        p { margin-bottom: 15px; }
        code { background-color: #f4f4f4; padding: 2px 5px; border-radius: 4px; }
        ul { list-style: none; padding: 0; }
        li { margin-bottom: 10px; }
        li a { text-decoration: none; color: #007bff; }
        li a:hover { text-decoration: underline; }
    </style>
</head>
<body>
    <h1>Welcome to PHPixie on ServBay</h1>
    <p>This page is being generated dynamically by your PHPixie application running on ServBay.</p>

    <h2>Link alle funzionalità di esempio:</h2>
    <ul>
        <li><a href="/home/memcached">Test Memcached</a></li>
        <li><a href="/home/redis">Test Redis</a></li>
        <li><a href="/home/add_user">Aggiungi un utente al database</a></li>
        <li><a href="/home/list_users">Elenca gli utenti dal database</a></li>
    </ul>

    <p>Assicurati di aver completato i passaggi di configurazione per database e caching.</p>

</body>
</html>

Accesso al sito di base

Dopo aver configurato il sito in ServBay e aggiunto il codice di esempio, puoi visitare il dominio impostato dal browser:

Apri il browser e vai su https://servbay-phpixie-test.local
Dovresti vedere la pagina "Welcome to PHPixie on ServBay" e i link alle funzionalità di esempio.

Se hai problemi ad accedere, verifica che:

ServBay sia attivo.
La configurazione del sito in ServBay sia corretta (dominio, tipo e root).
Il file hosts locale risolva correttamente servbay-phpixie-test.local (ServBay in genere lo gestisce automaticamente).
La versione PHP selezionata in ServBay sia abilitata.

Esempi di integrazione database e cache

PHPixie offre il supporto nativo a diversi sistemi di database e caching. ServBay fornisce pacchetti preinstallati come MySQL, PostgreSQL, Redis e Memcached, che puoi integrare facilmente nel tuo progetto PHPixie.

Nota importante: Prima delle operazioni sul database, assicurati che il relativo servizio (MySQL o PostgreSQL) sia avviato in ServBay e che sia stato creato un database per il progetto, ad esempio servbay_phpixie_app. Puoi creare il database tramite strumenti come Sequel Ace, Postico, TablePlus o da linea di comando. L’utente predefinito su ServBay è spesso root e la password password (verifica le tue impostazioni).

Configurazione della connessione al database

A seconda che tu usi MySQL o PostgreSQL, modifica assets/config/database.php. L'host di default ServBay è tipicamente 127.0.0.1.

Esempio di configurazione MySQL (assets/config/database.php):

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // la stringa di connessione va adattata alla configurazione ServBay e al tipo di database
        'connection' => 'mysql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Utente predefinito ServBay
        'password'  => 'password', // Password predefinita ServBay (modifica se necessario)
        'options'   => []
    ]
];

Esempio di configurazione PostgreSQL (assets/config/database.php):

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // la stringa di connessione va adattata alla configurazione ServBay e al tipo di database
        'connection' => 'pgsql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Utente predefinito ServBay
        'password'  => 'password', // Password predefinita ServBay (modifica se necessario)
        'options'   => []
    ]
];

Creazione delle tabelle tramite migration

PHPixie mette a disposizione strumenti CLI per gestire le migration, così puoi versionare la struttura del database.

Apri il terminale: Spostati nella root del progetto PHPixie:
bash
```
cd /Applications/ServBay/www/servbay-phpixie-app
```
1
Crea una migration: Usa la CLI di PHPixie per generare un file migration che creerà la tabella users:
bash
```
php pixie generate:migration create_users_table
```
1
Questo genera un nuovo file PHP nella directory assets/migrations, con il timestamp nel nome.

Modifica la migration: Apri il nuovo file (esempio: YYYY_MM_DD_HHMMSS_create_users_table.php) e modifica i metodi up() e down() per definire la struttura della tabella:

php

<?php

use PHPixie\Database\Migration;
use PHPixie\Database\Schema\Table;

class CreateUsersTable extends Migration
{
    public function up()
    {
        // Usa lo schema builder per creare la tabella 'users'
        $this->schema->create('users', function(Table $table) {
            $table->increments('id'); // Chiave primaria auto-incrementata
            $table->string('name'); // Colonna nome
            $table->string('email')->unique(); // Colonna email, unica
            $table->timestamps(); // Colonne created_at e updated_at
        });
    }

    public function down()
    {
        // Usa lo schema builder per eliminare la tabella 'users'
        $this->schema->drop('users');
    }
}

Esegui la migration: Esegui dal terminale, nella root del progetto, il comando:
bash
```
php pixie migrate
```
1
Se tutto va a buon fine, vedrai la conferma nel terminale. Puoi anche verificare tramite tool di gestione di database che la tabella users sia stata creata.

Usare il database relazionale (MySQL/PostgreSQL)

Nel controller di esempio src/App/HTTP/Controller/Home.php trovi già i metodi action_add_user e action_list_users che dimostrano come interagire, utilizzando il componente database di PHPixie, con MySQL o PostgreSQL.

Aggiungi un utente: visita https://servbay-phpixie-test.local/home/add_user per inserire un nuovo utente nella tabella users.
Elenca utenti: visita https://servbay-phpixie-test.local/home/list_users per ricevere la lista utenti in formato JSON.

Configurazione e utilizzo database NoSQL (Memcached/Redis)

ServBay integra sia Memcached che Redis e i relativi estensioni PHP. Devi solo configurare PHPixie per usarli.

Configurazione Memcached (assets/config/cache.php):

Crea o modifica il file assets/config/cache.php e inserisci la configurazione:

php

<?php

return [
    'default' => [
        'driver' => 'memcached',
        'servers' => [
            [
                'host'   => '127.0.0.1', // Indirizzo Memcached predefinito ServBay
                'port'   => 11211, // Porta predefinita ServBay
                'weight' => 100,
            ],
        ],
    ],
];

Configurazione Redis (assets/config/redis.php):

Crea o modifica il file assets/config/redis.php e inserisci la configurazione:

php

<?php

return [
    'default' => [
        'hostname' => '127.0.0.1', // Indirizzo Redis predefinito ServBay
        'port'     => 6379, // Porta predefinita ServBay
        'timeout'  => 0,
        'database' => 0, // Indice database Redis
    ],
];

Uso di Memcached/Redis:

Nei controller di esempio in src/App/HTTP/Controller/Home.php sono già presenti i metodi action_memcached e action_redis che dimostrano l’uso del componente cache di PHPixie (configurabile per Memcached o Redis tramite configurazione).

Test Memcached: visita https://servbay-phpixie-test.local/home/memcached per scrivere e poi leggere un valore da Memcached.
Test Redis: visita https://servbay-phpixie-test.local/home/redis per fare analoga operazione su Redis.

Assicurati di avere i rispettivi pacchetti (Memcached e Redis) attivi in ServBay.

Conclusione

Seguendo questi passaggi, hai creato, configurato ed avviato con successo un progetto PHPixie nell’ambiente locale su macOS grazie a ServBay. Ora sai come creare un progetto via Composer, come impostare il server web usando la funzione Siti Web di ServBay, configurare database e cache fondamentali e validare il funzionamento di tutte queste integrazioni.

L’ambiente integrato di ServBay rende il setup per lo sviluppo PHP notevolmente più semplice, permettendoti di concentrare la tua attenzione sulla scrittura del codice e lo sviluppo delle funzionalità. Speriamo che questa guida ti aiuti a partire rapidamente con PHPixie per il tuo prossimo progetto web!

Creare ed eseguire un progetto PHPixie su macOS con ServBay ​

Caratteristiche principali e vantaggi di PHPixie ​

Creazione ed esecuzione di un progetto PHPixie con ServBay ​

Prerequisiti ​

Creazione di un progetto PHPixie ​

Configurazione del server web ​

Aggiunta del codice di esempio ​

Accesso al sito di base ​

Esempi di integrazione database e cache ​

Configurazione della connessione al database ​

Creazione delle tabelle tramite migration ​

Usare il database relazionale (MySQL/PostgreSQL) ​

Configurazione e utilizzo database NoSQL (Memcached/Redis) ​

Conclusione ​