Laravel 4: एक Restful API पर एक शुरुआत (अपडेटेड)

Hindi (हिंदी) translation by Ashish Rampal (you can also view the original English article)

Restful API मुश्किल है! एक सफल डिजाइन करने और लिखने के लिए कई पहलू हैं। उदाहरण के लिए, कुछ विषयों जो आप स्वयं के हैंडलिंग में पा सकते हैं उनमें ऑथेंटिकेशन, हाइपरमीडिया/HATEOS, versioning, रेट लिमिट और कंटेंट नेगोशियेशन शामिल है। इन सभी कॉन्सेप्ट्स से निपटने के बजाय, चलो, REST की मूल बातों पर ध्यान दें। हम बेसिक ऑथेंटिकेशन सिस्टम के पीछे कुछ JSON अंतराल बनाएंगे, और प्रोसेस में कुछ Laravel 4 ट्रिक सीखेंगे।

अगर आपको अपने Laravel डेवलपमेंट में मदद की ज़रूरत है, तो Envato Market पर उपलब्ध कुछ उपयोगी Laravel स्क्रिप्ट और प्लगइन्स आज़माएं।

The App

आइए एक साधारण रीड-इट-लेटर वाले ऐप के लिए API बनाएं। यूज़र्स उन URL को बनाने, रीड, अपडेट और डिलीट करने में सक्षम होंगे जिन्हें वे बाद में पढ़ना चाहते हैं।

गोता लगाने और शुरू करने के लिए तैयार हैं?

Laravel 4 इनस्टॉल करें

Laravel 4 का नया इंस्टॉल बनाएं। यदि आप CLI के साथ काम कर रहे हैं, तो इस क्विकस्टार्ट गाइड को आज़माएं। अन्यथा, हमारे पास Nettuts+ पर एक वीडियो ट्यूटोरियल है जो प्रोसेस को कवर करता है।

हम सुरक्षित पासवर्ड हैशिंग के लिए पहले एन्क्रिप्शन key बनाने जा रहे हैं। आप इस प्रोजेक्ट रूट से इस कमांड को चलाकर आसानी से ऐसा कर सकते हैं:

1	$ php artisan key:generate

वैकल्पिक रूप से, आप अपने app/config/app.php एन्क्रिप्शन कुंजी को सरल बना सकते हैं:

/*
|--------------------------------------------------------------------------
| Encryption Key
|--------------------------------------------------------------------------
|
| This key is used by the Illuminate encrypter service and should be set
| to a random, long string, otherwise these encrypted values will not
| be safe. Make sure to change it before deploying any application!
|
*/

'key' => md5('this is one way to get an encryption key set'),

डेटाबेस

एक बार जब आपके पास Laravel 4 का वर्किंग इनस्टॉल हों, तो हम मस्ती के साथ शुरू कर सकते हैं। हम ऐप का डेटाबेस बनाकर शुरू करेंगे।

इसके लिए केवल दो डेटाबेस टेबल की आवश्यकता होगी:

Users, नाम और पासवर्ड सहित
URLs, url और डिस्क्रिप्शन सहित

डेटाबेस बनाने और पॉप्युलेट करने के लिए हम Laravel के migrations का उपयोग करेंगे।

अपने डेटाबेस को कॉन्फ़िगर करें

app/config/database.php एडिट करें और इसे अपनी डेटाबेस सेटिंग्स से भरें। नोट: इसका मतलब है कि इस एप्लिकेशन के उपयोग के लिए डेटाबेस बनाना। यह आर्टिकल एक MySQL डेटाबेस को मानता है।

'connections' => array(

    'mysql' => array(
        'driver'    => 'mysql',
        'host'      => 'localhost',
        'database'  => 'read_it_later',
        'username'  => 'your_username',
        'password'  => 'your_password',
        'charset'   => 'utf8',
        'collation' => 'utf8_unicode_ci',
        'prefix'    => '',
    ),
),

माइग्रेशन फ़ाइलें बनाएं

1	$ php artisan migrate:make create_users_table --table=users --create
2	$ php artisan migrate:make create_urls_table --table=urls --create

ये कमांड्स मूल माइग्रेशन स्क्रिप्ट सेट अप करते हैं जिन्हें हम डेटाबेस टेबल बनाने के लिए उपयोग करेंगे। अब हमारा काम उन्हें सही टेबल कॉलम से भरना है।

app/database/migrations/SOME_DATE_create_users_table.php एडिट करें और up() मेथड में जोड़ें:

public function up()
{
    Schema::create('users', function(Blueprint $table)
    {
        $table->increments('id');
        $table->string('username')->unique();
        $table->string('password');
        $table->timestamps();
    });
}

ऊपर, हम एक यूजरनाम (जो यूनिक होना चाहिए), एक पासवर्ड, साथ ही टाइमस्टैम्प सेट कर रहे हैं। इसे सेव करें, और अब app/database/migrations/SOME_DATE_create_urls_table.php एडिट करें, और up() मेथड में जोड़ें:

public function up()
{
    Schema::create('urls', function(Blueprint $table)
    {
        $table->increments('id');
        $table->integer('user_id');
        $table->string('url');
        $table->string('description');
        $table->timestamps();
    });
}

इस स्निपेट में एकमात्र महत्वपूर्ण नोट यह है कि हम user_id फ़ील्ड के माध्यम से url और users टेबल के बीच एक लिंक बना रहे हैं।

सैंपल यूज़र्स को जोड़ें

हम कुछ सैंपल यूज़र्स को बनाने के लिए Laravel के seeds का उपयोग कर सकते हैं।

app/database/seeds फ़ोल्डर में एक फ़ाइल बनाएं जिसमें टेबल के समान नाम है; हमारे मामले में, UserTableSeeder.php। इसमें जोड़ें:

<?php

class UserTableSeeder extends Seeder {

    public function run()
    {
        DB::table('users')->delete();

        User::create(array(
            'username' => 'firstuser',
            'password' => Hash::make('first_password')
        ));

        User::create(array(
            'username' => 'seconduser',
            'password' => Hash::make('second_password')
        ));
    }

}

इसके बाद, सुनिश्चित करें कि डेटाबेस सीड होने पर seeder क्लास को चलाया जाता है। app/database/seeds/DatabaseSeeder.php एडिट करें:

public function run()
{
    Eloquent::unguard();

    // Add or Uncomment this line
    $this->call('UserTableSeeder');
}

माइग्रेशन को चलाएं

यहां उन दो टेबल्स को बनाने का तरीका बताया गया है, और हमारे सैंपल यूज़र्स को इन्सर्ट करें।

// Create the two tables
$ php artisan migrate

// Create the sample users
$ php artisan db:seed

Models

Laravel 4 उत्कृष्ट Eloquent ORM का उपयोग जारी रखता है। इससे डाटाबेस को संभालने की प्रक्रिया एक स्नैप कॉल (चुटकी बजा कर) करेगी। हमें प्रति टेबल एक मॉडल की आवश्यकता होगी।

सौभाग्य से, Laravel User मॉडल सेटअप के साथ आता है, तो चलिए अपने urls टेबल के लिए एक मॉडल बनाते हैं।

app/model/Url.php फाइल बनाएं और एडिट करें।

<?php

class Url extends Eloquent {

    protected $table = 'urls';

}

ऑथेंटिकेशन

Laravel के filters हमारे लिए ऑथेंटिकेशन संभाल सकते हैं। विशेष रूप से, Laravel अब बेसिक ऑथेंटिकेशन फ़िल्टर के साथ आता है, जिसे हम अपने API रिक्वेस्ट्स के साथ उपयोग करने के लिए क्विक ऑथेंटिकेशन मॉडल के रूप में उपयोग कर सकते हैं।

यदि आप app/filter.php खोलते हैं, तो आप देखेंगे कि यह ऐसा दिखता है:

1	Route::filter('auth.basic', function()
2	{
3	return Auth::basic();
4	});

हमें बस एक एडजस्टमेंट करने की जरूरत है। डिफ़ॉल्ट रूप से, यह फ़िल्टर यूजर की पहचान करने के लिए "email" फ़ील्ड को ढूंढता है। चूंकि हम ईमेल के बजाय यूजरनाम का उपयोग कर रहे हैं, इसलिए हमें उस प्रेफरेंस को एडजस्ट करने की आवश्यकता है। Auth::basic() कॉल को हमारे यूजरनाम फ़ील्ड को पैरामीटर के रूप में बदलें:

1	Route::filter('auth.basic', function()
2	{
3	return Auth::basic("username");
4	});

Routes

आइए इसका परीक्षण करें। testauth नामक एक रूट बनाएं, और सुनिश्चित करें कि हमारे auth.basic फ़िल्टर इससे पहले चलता है।

app/routes.php एडिट करें:

1	Route::get('/authtest', array('before' => 'auth.basic', function()
2	{
3	return View::make('hello');
4	}));

हम इसे एक curl रिक्वेस्ट के साथ परीक्षण कर सकते हैं। अपने टर्मिनल से, Laravel के निर्माण को इंगित करने का प्रयास करें। मेरे में, ऐसा लगता है (आपका URL शायद अलग होगा!):

$ curl -i localhost/l4api/public/index.php/authtest
HTTP/1.1 401 Unauthorized
Date: Tue, 21 May 2013 18:47:59 GMT
WWW-Authenticate: Basic
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8

Invalid credentials

जैसा कि आप देख सकते हैं, एक अनऑथॉरिज़ रिक्वेस्ट का पता लगाया गया है और एक "Invalid Credentials" मैसेज 401 स्टेटस कोड के साथ रीटर्न कर दिया गया है। इसके बाद, बेसिक ऑथेंटिकेशन सहित प्रयास करें।

$ curl --user firstuser:first_password localhost/l4api/public/index.php/authtest
HTTP/1.1 200 OK
Date: Tue, 21 May 2013 18:50:51 GMT
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8

<h1>Hello World!</h1>

इसने काम कर दिया!

इस बिंदु पर, हमारे API का बेसलाइन काम पूरा हो जाता है। हमारे पास है:

इनस्टॉल किया गया Laravel 4
हमारे डेटाबेस बना लिया
हमारे मॉडल बना लिया
एक ऑथेंटिकेशन मॉडल बना लिया

फंक्शनल रिक्वेस्ट को बनाना

आप Laravel के RESTful कंट्रोलर्स से परिचित हो सकते हैं। वे अभी भी Laravel 4 में मौजूद हैं; हालांकि, हम Laravel के Resourceful Controllers का भी उपयोग कर सकते हैं, जो कुछ paradigm सेटअप करते हैं जिनका उपयोग हम एक कंसिस्टेंट API इंटरफ़ेस बनाने के लिए कर सकते हैं। हम एक रिसोर्सफुल कंट्रोलर का उपयोग करेंगे।

रिसोर्सफुल कंट्रोलर में प्रत्येक मेथड को संभालने के लिए यहां एक ब्रेकडाउन दिया गया है। कृपया ध्यान दें कि आप /resource/create और /resource/{id}/edit routes को हटा सकते हैं, क्योंकि हमें किसी API में 'create' या 'edit' फ़ॉर्म दिखाने की आवश्यकता नहीं होगी।

एक रिसोर्सफुल कंट्रोलर बनाएँ

1	$ php artisan controller:make UrlController

इसके बाद, कंट्रोलर का उपयोग करने के लिए एक रूट को निर्धारित करें, और प्रत्येक रूट को ऑथेंटिकेटेड करने की आवश्यकता है।

app/routes.php एडिट करें और जोड़ें:

// Route group for API versioning
Route::group(array('prefix' => 'api/v1', 'before' => 'auth.basic'), function()
{
    Route::resource('url', 'UrlController');
});

वहां कुछ चीजें हो रही हैं।

यह http://example.com/api/v1/url पर किए गए रिक्वेस्ट्स का जवाब देने जा रहा है।
अगर हमें हमारे API का विस्तार करने की ज़रूरत है, तो यह हमें अतिरिक्त रूट जोड़ने की अनुमति देता है। उदाहरण के लिए, यदि आप यूजर एन्ड-पॉइंट जोड़ते हैं, जैसे /api/v1/user।
हमारे API को वर्जेनिंग (versioning) करने के लिए एक नेमिंग मैकेनिज्म भी है। यह हमें पुराने वर्जन को ब्रेक किये बिना नए API वर्जन को रोल करने का मौका देता है - हम बस एक v2 रूट ग्रुप बना सकते हैं, और इसे एक नए कंट्रोलर को पॉइंट कर सकते हैं!

नोट: आप अधिक एडवांस API वर्जनिंग तकनीकों पर विचार करना चाहेंगे, जैसे एक Accept हेडर या सबडोमेन का उपयोग करना जो आपको अलग-अलग API वर्जन को अलग कोड बेस पॉइंट करने में मदद कर सकता है।

फंक्शनलिटी जोड़ें

नयी app/controller/UrlController.php फ़ाइल एडिट करें:

// Edit this:
public function index()
{
    return 'Hello, API';
}

आइए इसका परीक्षण करें:

$ curl -i localhost/l4api/public/index.php/api/v1/url
HTTP/1.1 401 Unauthorized
Date: Tue, 21 May 2013 19:02:59 GMT
WWW-Authenticate: Basic
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8

Invalid credentials.

$ curl --user firstuser:first_password localhost/l4api/public/index.php/api/v1/url
HTTP/1.1 200 OK
Date: Tue, 21 May 2013 19:04:19 GMT
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8

Hello, API

अब हमारे पास ऑथेंटिकेशन के साथ एक रिसोर्सफुल कंट्रोलर है, और फंक्शनलिटी जोड़ने के लिए तैयार हैं।

एक URL बनाएँ

app/controller/UrlController.php एडिट करें:

/**
 * Store a newly created resource in storage.
 *
 * @return Response
 */
public function store()
{
    $url = new Url;
    $url->url = Request::get('url');
    $url->description = Request::get('description');
    $url->user_id = Auth::user()->id;

    // Validation and Filtering is sorely needed!!
    // Seriously, I'm a bad person for leaving that out.

    $url->save();

    return Response::json(array(
        'error' => false,
        'urls' => $urls->toArray()),
        200
    );
}

यह एक और curl रिक्वेस्ट के साथ परीक्षण करने का समय है। यह एक POST रिक्वेस्ट भेजेगा, जो उपरोक्त बनाए गए store() मेथड से मेल खाएगा।

$ curl -i --user firstuser:first_password -d 'url=http://google.com&description=A Search Engine' localhost/l4api/public/index.php/api/v1/url
HTTP/1.1 201 Created
Date: Tue, 21 May 2013 19:10:52 GMT
Content-Type: application/json

{"error":false,"message":"URL created"}

कूल! चलिए अपने दोनों यूज़र्स के लिए कुछ और बनाते हैं।

$ curl --user firstuser:first_password -d 'url=http://fideloper.com&description=A Great Blog' localhost/l4api/public/index.php/api/v1/url

$ curl --user seconduser:second_password -d 'url=http://digitalsurgeons.com&description=A Marketing Agency' localhost/l4api/public/index.php/api/v1/url

$ curl --user seconduser:second_password -d 'url=http://www.poppstrong.com/&description=I feel for him' localhost/l4api/public/index.php/api/v1/url

इसके बाद, आइए URL रिट्रीव करने के लिए मेथड्स को बनाएं।

/**
 * Display a listing of the resource.
 *
 * @return Response
 */
public function index()
{
    //Formerly: return 'Hello, API';

    $urls = Url::where('user_id', Auth::user()->id)->get();

    return Response::json(array(
        'error' => false,
        'urls' => $urls->toArray()),
        200
    );
}

/**
 * Display the specified resource.
 *
 * @param  int  $id
 * @return Response
 */
public function show($id)
{
    // Make sure current user owns the requested resource
    $url = Url::where('user_id', Auth::user()->id)
            ->where('id', $id)
            ->take(1)
            ->get();

    return Response::json(array(
        'error' => false,
        'urls' => $url->toArray()),
        200
    );
}

आइए उनका परीक्षण करें:

$ curl --user firstuser:first_password localhost/l4api/public/index.php/api/v1/url
{
    "error": false,
    "urls": [
       {
            "created_at": "2013-02-01 02:39:10",
            "description": "A Search Engine",
            "id": "2",
            "updated_at": "2013-02-01 02:39:10",
            "url": "http://google.com",
            "user_id": "1"
        },
        {
            "created_at": "2013-02-01 02:44:34",
            "description": "A Great Blog",
            "id": "3",
            "updated_at": "2013-02-01 02:44:34",
            "url": "http://fideloper.com",
            "user_id": "1"
        }
    ]
}

$ curl --user firstuser:first_password localhost/l4api/public/index.php/api/v1/url/1
{
    "error": false,
    "urls": [
        {
            "created_at": "2013-02-01 02:39:10",
            "description": "A Search Engine",
            "id": "2",
            "updated_at": "2013-02-01 02:39:10",
            "url": "http://google.com",
            "user_id": "1"
        }
    ]
}

लगभग हो गया। आइए अब यूज़र्स को URL हटाने की अनुमति दें।

/**
 * Remove the specified resource from storage.
 *
 * @param  int  $id
 * @return Response
 */
public function destroy($id)
{
    $url = Url::where('user_id', Auth::user()->id)->find($id);

    $url->delete();

    return Response::json(array(
        'error' => false,
        'message' => 'url deleted'),
        200
        );
}

अब, हम एक DELETE रिक्वेस्ट का उपयोग करके एक URL को डिलीट सकते हैं:

$ curl -i -X DELETE --user firstuser:first_password localhost/l4api/public/index.php/api/v1/url/1
HTTP/1.1 200 OK
Date: Tue, 21 May 2013 19:24:19 GMT
Content-Type: application/json

{"error":false,"message":"url deleted"}

अंत में, आइए यूज़र्स को URL अपडेट करने दें।

/**
 * Update the specified resource in storage.
 *
 * @param  int  $id
 * @return Response
 */
public function update($id)
{
    $url = Url::where('user_id', Auth::user()->id)->find($id);

    if ( Request::get('url') )
    {
        $url->url = Request::get('url');
    }

    if ( Request::get('description') )
    {
        $url->description = Request::get('description');
    }

    $url->save();

    return Response::json(array(
        'error' => false,
        'message' => 'url updated'),
        200
    );
}

URL अपडेट का परीक्षण करने के लिए, चलाएं:

$ curl -i -X PUT --user seconduser:second_password -d 'url=http://yahoo.com' localhost/l4api/public/index.php/api/v1/url/4
HTTP/1.1 200 OK
Date: Tue, 21 May 2013 19:34:21 GMT
Content-Type: application/json

{"error":false,"message":"url updated"}

// View our changes
$ curl --user seconduser:second_password localhost/l4api/public/index.php/api/v1/url/4
{
    "error": false,
    "urls": [
        {
            "created_at": "2013-02-01 02:44:34",
            "description": "I feel for him",
            "id": "3",
            "updated_at": "2013-02-02 18:44:18",
            "url": "http://yahoo.com",
            "user_id": "1"
        }
    ]
}

और बस

अब हमारे पास पूरी तरह से काम करने वाली API की शुरुआत है। मुझे आशा है कि आपने Laravel 4 के साथ एक API कैसे चलाना है, इस बारे में बहुत कुछ सीखा है।

संक्षेप में, हमने इस लेसन में निम्न को प्राप्त किया:

Laravel को इनस्टॉल करना
माइग्रेशन और सीडिंग का उपयोग कर डेटाबेस बनाना
Eloquent ORM मॉडल का प्रयोग करना
बेसिक Auth के साथ ऑथेंटिकेशन करना
API वर्जन सहित रूट सेट करना
रिसोर्सफुल कंट्रोलर्स का उपयोग कर API की फंक्शनलिटी को बनाना

अगले स्टेप्स

यदि आप अपने API को एक पायदान पर पुश करना चाहते हैं, तो आप निम्न में से किसी एक को अगले स्टेप के रूप में देख सकते हैं।

वेलिडेशन (हिंट: Laravel में एक वेलिडेशन लाइब्रेरी है)।
API-रिक्वेस्ट एरर हैंडलिंग - API रिक्वेस्ट्स पर HTML रिस्पांस प्राप्त करना अभी भी संभव है (हिंट: Laravel एरर हैंडलिंग, साथ ही कंटेंट नेगोशियेशन।)
कंटेंट नेगोशियेशन - स्वीकृति हेडर के लिए सुनना। (हिंट: Laravel की Request क्लास आपको रिक्वेस्ट हैंडर्स देगी)।
API क्राफ्ट Google ग्रुप को देखें।
विभिन्न प्रकार के कैशिंग के बारे में जानें और वेलिडेशन कैशिंग आपके API को कैसे सुधार सकता है।
अपने कोड को यूनिट टेस्ट करें।
Apigee एक महान API रिसोर्स को देखें।
Envato Market पर उपलब्ध कुछ उपयोगी Laravel स्क्रिप्ट और प्लगइन्स को आज़माएं।