ServBay में Slim प्रोजेक्ट बनाना और चलाना

इस गाइड में आपको बताया जाएगा कि कैसे ServBay — एक शक्तिशाली लोकल वेब डेवलपमेंट एनवायरनमेंट — में PHP बेस्ड Slim Framework प्रोजेक्ट को तेज़ी से बनाएं, सेटअप करें और चलाएं। ServBay में इंटीग्रेटेड PHP, वेब सर्वर (Caddy/Nginx/Apache) और कई तरह के डेटाबेस पैकेज उपलब्ध हैं, जिससे ये Slim डेवलपमेंट के लिए आदर्श प्लेटफॉर्म बन जाता है।

Slim क्या है?

Slim एक हल्का PHP माइक्रोफ्रेमवर्क है, जिसे सिंपल तथा पावरफुल वेब एप और API जल्दी बनाने के लिए डिजाइन किया गया है। इसमें कोर रूटिंग, रिक्वेस्ट-रिस्पॉन्स हैंडलिंग जैसी मुख्य सुविधाएं हैं, जिससे ये तेज़ डेवेलपमेंट, डिप्लॉयमेंट और छोटे से मिडियम स्केल प्रोजेक्ट्स या कॉम्प्लेक्स एप के बेस के रूप में बहुत अच्छा है।

Slim की प्रमुख विशेषताएँ और फायदे

हल्कापन: Slim फ्रेमवर्क की कोर लाइब्रेरी बहुत छोटी है, कम रिसोर्स लेती है और फास्ट स्टार्टअप देती है, छोट–मझोले एप या माइक्रोसर्विसेस के लिए उपयुक्त।
लचीलापन: Slim को प्लगइन करने के लिए बना है, जिससे आप आसानी से थर्ड–पार्टी टूल्स (जैसे टेम्पलेट इंजन, ORM, ऑथेंटिकेशन लाइब्रेरी, आदि) को जोड़ सकते हैं और अपने प्रोजेक्ट के अनुरूप बेस्ट टूल्स चुन सकते हैं।
इस्तेमाल में सरल: सिम्पल API और क्लियर डाक्यूमेंटेशन के साथ, डेवलपर्स स्लिम के कोर फीचर्स जल्दी समझ कर स्टार्ट कर सकते हैं।
पावरफुल रूटिंग: कई HTTP मेथड्स (जैसे GET, POST, PUT, DELETE आदि) और कंप्लेक्स रूटिंग (रूट ग्रुप्स, मिडलवेयर, पैरामीटर कैप्चर) सपोर्ट करता है।
मिडलवेयर सपोर्ट: स्लिम का मिडलवेयर लेयर आपको एप्प्लिकेशन लॉजिक के पहले व रिक्वेस्ट या रिस्पॉन्स भेजने के बाद खास टास्क (जैसे ऑथेंटिकेशन, लॉगिंग, CORS हैंडलिंग, आदि) रन करने देता है।

Slim RESTful API, रैपिड प्रोटोटाइपिंग, तथा इंडीपेंडेंट टूल्स बनाने के लिए बेस्ट विकल्प है।

ServBay का उपयोग कर Slim प्रोजेक्ट सेटअप और रन करना

इस ट्यूटोरियल में ServBay का प्री–कन्फ़िगरड PHP एनवायरनमेंट व “ वेबसाइट” फीचर यूज़ कर के वेब सर्वर सेट करेंगे और स्लिम प्रोजेक्ट में आसान एक्सेस देंगे।

आवश्यकताएँ

शुरू करने से पहले ये सुनिश्चित करें:

ServBay इंस्टाल और चालू होना चाहिए: आपका macOS या Windows सिस्टम पर ServBay सही से इंस्टॉल और रनिंग होना चाहिए।
Composer शामिल है: ServBay में Composer पहले से इंटीग्रेटेड है, अलग से इंस्टाल करने की ज़रूरत नहीं।

Slim प्रोजेक्ट बनाना

ServBay सुझाव देता है कि सभी वेबसाइट प्रोजेक्ट्स नीचे दिए गए डायरेक्ट्री में रखें, ताकि मैनेजमेंट और कन्फिग्रेशन आसान हो:

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

ServBay वेबसाइट रूट में जाएँ:
macOS:
bash
```
cd /Applications/ServBay/www
```
1
Windows:
cmd
```
cd C:\ServBay\www
```
1
प्रोजेक्ट फोल्डर बनाएँ: Slim प्रोजेक्ट हेतु नया फोल्डर बनाएँ।
bash
```
mkdir servbay-slim-app
```
1
प्रोजेक्ट फोल्डर में जाएँ:
bash
```
cd servbay-slim-app
```
1
Composer से Slim इंस्टाल करें: Composer कमांड चलाएँ, Slim फ्रेमवर्क और PSR-7 पैकेज इंस्टाल करने के लिए।
bash
```
composer require slim/slim "^4.0" slim/psr7 -W
```
1
ये Slim फ्रेमवर्क और slim/psr7 लाइब्रेरी आपके vendor फोल्डर में डाऊनलोड कर देगा, साथ ही composer.json और composer.lock बना देगा।

Slim एप्लिकेशन इनिशियलाइज़ करना

एंट्री फाइल बनाएं: आमतौर पर Slim के लिए एक सिंगल एंट्री फाइल (public/index.php) होती है, जो सभी रिक्वेस्ट हैंडल करती है। प्रोजेक्ट रूट में public फोल्डर बनाएं और उसमें index.php फाइल बनाएं।
bash
```
mkdir public
touch public/index.php
```
1
2

एंट्री फाइल एडिट करें: public/index.php फाइल खोलें और ये बेसिक स्लिम कोड डालें:

php

<?php
// Composer ऑटो–लोडिंग फाइल को लोड करें
require __DIR__ . '/../vendor/autoload.php';

// जरुरी PSR-7 इंटरफेस व Slim फैक्टरी इम्पोर्ट करें
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

// Slim एप्लिकेशन इंस्टेंस बनाएं
$app = AppFactory::create();

// एक सरल रूट जोड़ें: GET रिक्वेस्ट को रूट '/' पर हैंडल करें
$app->get('/', function (Request $request, Response $response, $args) {
    // रिस्पॉन्स बॉडी में कंटेंट लिखें
    $response->getBody()->write("Hello ServBay!");
    // रिस्पॉन्स ऑब्जेक्ट लौटाएं
    return $response;
});

// स्लिम एप रन करें
$app->run();

यह सबसे सिंपल Slim ऐप है, जिसमें रूट URL (/) के लिए GET रिक्वेस्ट हैंडल होती है और "Hello ServBay!" टेक्स्ट दिखाया जाता है।

ServBay वेबसाइट सेटअप

अपने स्लिम प्रोजेक्ट को ब्राउज़र में एक्सेस करने हेतु ServBay में “ वेबसाइट” (पुराने वर्शन में “होस्ट”) सेटअप करना जरूरी है।

ServBay एप का इंटरफेस खोलें।
“वेबसाइट” (Websites) फीचर मॉड्यूल में जाएं।
नई वेबसाइट एड करने के लिए क्लिक करें।
नीचे दिए गए विकल्प भरें:
- नाम (Name): My First Slim Dev Site (या कोई भी मनपसंद नाम)
- डोमेन (Domain): servbay-slim-test.local (लोकल डेवलपमेंट के लिए .local या .test डोमेन इस्तेमाल करें)
- वेबसाइट प्रकार (Website Type): PHP
- PHP संस्करण (PHP Version): जरुरत के मुताबिक वर्शन चुनें, जैसे 8.3।
- डॉक्युमेंट रूट (Document Root): ब्राउज़ करें और अपने प्रोजेक्ट के public डायरेक्ट्री सेलेक्ट करें:
  - macOS: /Applications/ServBay/www/servbay-slim-app/public
  - Windows: C:\ServBay\www\servbay-slim-app\public
  क्योंकि Slim का एंट्री फाइल (index.php) public में होती है, तो वेब सर्वर को इसी डायरेक्ट्री पॉइंट करना चाहिए।
वेबसाइट सेटिंग्स सेव करें। ServBay वेब सर्वर कन्फिगURATION ऑटोमेटिकली अपडेट कर देता है।

विस्तृत स्टेप्स के लिए देखें पहली वेबसाइट जोड़ें।

अपनी Slim वेबसाइट देखें

सेटअप पूरा होने पर, अपने ब्राउज़र में https://servbay-slim-test.local पर जाएँ।

अगर सब सही रहा, तो आपको "Hello ServBay!" टेक्स्ट दिखेगा। इसका मतलब Slim प्रोजेक्ट ServBay के वेब सर्वर पर ठीक से रन हो रहा है।

डेटाबेस इंटीग्रेशन के उदाहरण

Slim में खुद की डेटाबेस लेयर नहीं होती, लेकिन PHP डेटाबेस पैकेज का इंटीग्रेशन बहुत आसान है। यहाँ हम Laravel का Eloquent ORM (illuminate/database पैकेज) इस्तेमाल करते हुए MySQL व PostgreSQL कनेक्ट करेंगे, साथ ही Memcached और Redis इंटीग्रेशन भी दिखाएँगे।

पूर्वशर्तें: डेटाबेस बनाना और माइग्रेशन चलाना

डेटाबेस इंटीग्रेशन से पहले, ServBay में सम्बंधित डेटाबेस बनाएं और एप के लिए टेबल स्ट्रक्चर सेट करें।

डेटाबेस बनाएं:
- ServBay एप इंटरफेस खोलकर, आवश्यक डेटाबेस पैकेज (जैसे MySQL या PostgreSQL) में जाएं।
- phpMyAdmin (MySQL/MariaDB के लिए), pgAdmin (PostgreSQL के लिए) या कमांड लाइन से नया डेटाबेस बनाएं, जैसे नाम रखें servbay_slim_app।
- आमतौर पर root यूजर का पासवर्ड password होता है, जिसे ServBay सेटिंग्स में देख/बदल सकते हैं।

Phinx इंस्टाल और कन्फिगर करें: Phinx एक लोकप्रिय PHP डेटाबेस माइग्रेशन टूल है।

प्रोजेक्ट रूट में Composer से Phinx इंस्टाल करें:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require robmorgan/phinx
```
1

Phinx कन्फिगरेशन इनिशियलाइज़ करें:

bash

vendor/bin/phinx init

अब phinx.yml फाइल बन जाएगी, जिसमें कनेक्शन कन्फिगरेशन जैसे भरें:

yaml

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

environments:
    default_migration_table: phinxlog
    default_environment: development # या आप का environment नाम

    development: # डेटाबेस के मुताबिक संशोधित करें
        adapter: mysql # या pgsql
        host: 127.0.0.1
        name: servbay_slim_app # डेटाबेस नाम
        user: root
        pass: password # डेटाबेस पासवर्ड
        port: 3306 # MySQL डिफॉल्ट पोर्ट, PostgreSQL के लिए 5432
        charset: utf8mb4
        collation: utf8mb4_unicode_ci

version_order: creation

माइग्रेशन फाइल बनाएं: Phinx से नया माइग्रेशन जेनरेट करें।

bash

vendor/bin/phinx create CreateUsersTable

माइग्रेशन फोल्डर में जो PHP फाइल बनी है इसमें — change() method को ऐसा लिखें:

php

<?php

declare(strict_types=1);

use Phinx\Migration\AbstractMigration;

final class CreateUsersTable extends AbstractMigration
{
    /**
     * Change Method.
     *
     * Write your reversible migrations using this method.
     *
     * More information on writing migrations is available here:
     * https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
     *
     * Remember to call "create()" or "update()" and NOT "save()" when working
     * with the Table class.
     */
    public function change(): void
    {
        $table = $this->table('users');
        $table->addColumn('name', 'string')
              ->addColumn('email', 'string', ['unique' => true])
              ->addTimestamps() // created_at और updated_at कॉलम जोड़ें
              ->create();
    }
}

माइग्रेशन रन करें: प्रोजेक्ट रूट से Phinx माइग्रेशन कमांड चलाएं:
bash
```
vendor/bin/phinx migrate
```
1
ध्यान दें: नीचे दिए गए डेटाबेस कोड से पहले डेटाबेस बनाना और माइग्रेशन पूरा करना जरूरी है।

illuminate/database इस्तेमाल करके

Laravel की पैकेज (illuminate/database) ORM व क्वेरी बिल्डर के रूप में उपयोग करें।

illuminate/database इंस्टाल करें: प्रोजेक्ट रूट में डिपेंडेंसी स्थापित करें:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require illuminate/database
```
1

public/index.php में डेटाबेस कनेक्शन इनिशियलाइज़ करें: require __DIR__ . '/../vendor/autoload.php'; के बाद और $app = AppFactory::create(); से पहले यह कोड डालें:

php

// ... अन्य require और use statements ...

use Illuminate\Database\Capsule\Manager as Capsule; // Capsule मैनेजर इम्पोर्ट करें

// Eloquent ORM इनिशियलाइज़ करें
$capsule = new Capsule;

// डेटाबेस कनेक्शन कन्फिगरेशन जोड़ें (डेटाबेस के प्रकार के अनुसार driver व बाकी पैरामीटर बदलें)
$capsule->addConnection([
    'driver' => 'mysql', // या 'pgsql'
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app', // डेटाबेस नाम
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8mb4',
    'collation' => 'utf8mb4_unicode_ci',
    'prefix' => '',
    // PostgreSQL के लिए:
    // 'schema' => 'public',
]);

// ग्लोबली उपलब्ध कराएँ
$capsule->setAsGlobal();

// Eloquent प्रारंभ करें
$capsule->bootEloquent();

// ... Slim एप्लिकेशन ($app = AppFactory::create();) ...

MySQL उदाहरण

मान लें कि ServBay में MySQL पैकेज एक्टिव है, डेटाबेस servbay_slim_app और माइग्रेशन से users टेबल बन चुकी है।

public/index.php में $app->run(); से पहले ये रूट जोड़ें:

php

// ... इनिशियलाइज़ेशन कोड और '/' रूट ...

use Illuminate\Database\Capsule\Manager as Capsule; // Ensure imported

// यूजर जोड़ने का रूट
$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', // 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);
    }
    return $response;
});

// यूजर डेटा प्राप्त करने का रूट
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // 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();

एक्सेस:

https://servbay-slim-test.local/mysql-add-user — ये users टेबल में एक नया यूज़र ऐड करेगा।
https://servbay-slim-test.local/mysql-get-users — सभी यूज़र्स JSON में दिखाएगा।

PostgreSQL उदाहरण

मान लें ServBay में PostgreSQL पैकेज एक्टिव है, डेटाबेस servbay_slim_app बन चुका है और माइग्रेशन से users टेबल तैयार है (Phinx कन्फिग में adapter 'pgsql' और port '5432' हों)।

public/index.php में कनेक्शन कन्फिग में driver को pgsql और schema: public जोड़ें:

php

$capsule->addConnection([
    'driver' => 'pgsql',
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8',
    'prefix' => '',
    'schema' => 'public',
]);
// ... बाकी Eloquent कोड एक जैसा ...

अब $app->run(); से पहले ये रूट डालें:

php

// ... इनिशियल कोड और '/' रूट ...
// ... MySQL रूट्स (अगर जरूरी हों) ...

use Illuminate\Database\Capsule\Manager as Capsule; // Ensure imported

// यूज़र जोड़ने का रूट
$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;
});

// यूज़र डेटा लाने का रूट
$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();

एक्सेस:

https://servbay-slim-test.local/pgsql-add-user — PostgreSQL के users टेबल में नया यूज़र ऐड करेगा।
https://servbay-slim-test.local/pgsql-get-users — JSON में मोबाइल सारे यूज़र्स दिखाएगा।

Memcached उदाहरण

ServBay में Memcached पैकेज और PHP ext-memcached एक्सटेंशन है। बस अब PHP क्लाइंट लाइब्रेरी इंस्टाल करनी होगी (हम memcached/memcached इस्तेमाल कर रहे हैं)।

Memcached क्लाइंट लाइब्रेरी इंस्टाल करें:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require memcached/memcached
```
1

public/index.php में Memcached रूट डालें: $app->run(); से पहले ये रूट ऐड करें:

php

// ... Initialization और डेटाबेस रूट्स ...

// Memcached का रूट
$app->get('/memcached-example', function (Request $request, Response $response, $args) {
    // Memcached क्लाइंट बनाएं
    $memcached = new Memcached();
    // सर्वर जोड़ें (ServBay डिफॉल्ट 127.0.0.1:11211)
    $memcached->addServer('127.0.0.1', 11211);

    $cacheKey = 'my_servbay_cache_key';
    // कैश से डेटा निकालें
    $cachedData = $memcached->get($cacheKey);

    if ($cachedData === false) {
        // कैश में डेटा नहीं है, तो नया जनरेट करके सेव करें
        $cachedData = 'Hello Memcached from ServBay! This was not cached.';
        // डेटा कैश में 60 सेकंड के लिए सेव करें
        $memcached->set($cacheKey, $cachedData, 60);
        $response->getBody()->write($cachedData);
    } else {
        // अगर कैश से डेटा मिला तो सीधे दिखाएं
        $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
    }

    return $response;
});

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

एक्सेस करें: https://servbay-slim-test.local/memcached-example। पहली बार "This was not cached." दिखेगा, बाद में (कैश खत्म होने से पहले) "This was served from cache." मिलेगा।

Redis उदाहरण

ServBay में Redis पैकेज और PHP ext-redis एक्सटेंशन है; बस एक PHP क्लाइंट लाइब्रेरी चाहिए (हम predis/predis इस्तेमाल करते हैं)।

Redis क्लाइंट लाइब्रेरी इंस्टाल करें:
- macOS: /Applications/ServBay/www/servbay-slim-app
- Windows: C:\ServBay\www\servbay-slim-app
bash
```
composer require predis/predis
```
1

public/index.php में Redis रूट डालें: $app->run(); से पहले ये कोड डालें:

php

// ... Initialization और डेटाबेस रूट्स ...
// ... Memcached रूट (अगर चाहिए) ...

use Predis\Client as RedisClient; // Predis क्लाइंट इम्पोर्ट करें

// Redis का रूट
$app->get('/redis-example', function (Request $request, Response $response, $args) {
    try {
        // Redis क्लाइंट बनाएं (ServBay डिफॉल्ट 127.0.0.1:6379)
        $redis = new RedisClient([
            'scheme' => 'tcp',
            'host' => '127.0.0.1',
            'port' => 6379,
        ]);

        $cacheKey = 'my_servbay_redis_cache_key';
        // कैश से डेटा पाएं
        $cachedData = $redis->get($cacheKey);

        if ($cachedData === null) {
            // कैश में डेटा नहीं तो नया बनाएं और सेव करें
            $cachedData = 'Hello Redis from ServBay! This was not cached.';
            // 60 सेकंड के लिए कैश करें
            $redis->setex($cacheKey, 60, $cachedData);
            $response->getBody()->write($cachedData);
        } else {
            // अगर कैश में डेटा है तो वह दिखाएं
            $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
        }
    } catch (\Exception $e) {
        // कनेक्शन या ऑपरेशन error हैंडल करें
        $response->getBody()->write('Error connecting to Redis or performing operation: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }

    return $response;
});

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

एक्सेस करें: https://servbay-slim-test.local/redis-example। पहली बार "This was not cached." दिखेगा, फिर कैश रहते "This was served from cache." आएगा।

निष्कर्ष

इन स्टेप्स से आपने ServBay लोकल डेवलपमेंट एनवायरनमेंट में एक Slim Framework प्रोजेक्ट बनाया, ServBay की वेबसाइट फीचर से प्रोजेक्ट होस्ट किया और एक्सेस किया। आपने देखा कि कैसे ServBay के पैकेज (जैसे: MySQL, PostgreSQL, Memcached, Redis), व PHP एक्सटेंशन के जरिए डेटाबेस और कैशिंग को अपने Slim ऐप में इंटीग्रेट कर सकते हैं। ServBay लोकल एनवायरनमेंट को साधारण और ऑटोमैटिक बनाता है, जिससे आप अपने स्लिम एप्लिकेशन के डेवेलपमेंट पर ज्यादा ध्यान दे सकते हैं।

ServBay में Slim प्रोजेक्ट बनाना और चलाना ​

Slim क्या है? ​

Slim की प्रमुख विशेषताएँ और फायदे ​

ServBay का उपयोग कर Slim प्रोजेक्ट सेटअप और रन करना ​

आवश्यकताएँ ​

Slim प्रोजेक्ट बनाना ​

Slim एप्लिकेशन इनिशियलाइज़ करना ​

ServBay वेबसाइट सेटअप ​

अपनी Slim वेबसाइट देखें ​

डेटाबेस इंटीग्रेशन के उदाहरण ​

पूर्वशर्तें: डेटाबेस बनाना और माइग्रेशन चलाना ​

illuminate/database इस्तेमाल करके ​

MySQL उदाहरण ​

PostgreSQL उदाहरण ​

Memcached उदाहरण ​

Redis उदाहरण ​

निष्कर्ष ​