Laravel API: crie e teste uma API no Laravel

Laravel Eloquent é uma maneira fácil de interagir com seu banco de dados. É um mapeador relacional de objeto (ORM) que simplifica as complexidades dos bancos de dados, fornecendo um modelo para interagir com tabelas.

Como tal, o Laravel Eloquent possui excelentes ferramentas para criar e testar APIs para dar suporte ao seu desenvolvimento. Neste artigo prático, você verá como é fácil criar e testar APIs usando o Laravel.

Nesta demonstração, você começará criando um modelo que pode ser usado para construir a API e a tabela de banco de dados. Em seguida, você verá como adicionar um controlador como uma camada de lógica de negócios e uma rota para completar a API. Você aprenderá como executar APIs de teste usando o Postman antes de finalmente se concentrar na autenticação e no tratamento de erros.

Pré-requisitos

Para começar, aqui está o que você precisa:

• Laravel versão 8 ou 9
• Compositor
• Carteiro
• XAMPPGenericName
• Conhecimento básico de APIs e PHP

Noções básicas da API

Comece criando um novo projeto Laravel usando <code>composer</code>:

 composer create-project laravel/laravel laravel-api-create-test

Para iniciar o servidor, execute o seguinte comando, que executa o servidor de aplicativos na porta 8000:

 cd laravel-api-create-test php artisan serve

Você deve ver a seguinte tela:

Em seguida, crie um modelo com um sinalizador -m para a migração usando o código abaixo:

 php artisan make:model Product -m

Agora atualize o arquivo de migração para incluir o campo obrigatório. Adicione campos de título e descrição para o modelo do produto e esses dois campos de tabela dentro do arquivo database/migrations/{date_stamp}_create_products_table.php .

 $table->string('title'); $table->longText('description');

O próximo passo é tornar esses campos preenchíveis. Dentro de app/Models/ Product.php , torne os campos title e description preenchíveis.

 protected $fillable = ['title', 'description'];

Como criar um controlador

Agora, crie um arquivo de controlador para o produto executando o seguinte comando. Isso criará o arquivo app/Http/Controllers/Api/ProductController.php .

 php artisan make:controller Api\\ProductController --model=Product

Agora, adicione a lógica para criar e recuperar os produtos. Dentro do método index , adicione o seguinte código para recuperar todos os produtos:

 $products = Product::all(); return response()->json([ 'status' => true, 'products' => $products ]);

Depois disso, você deve adicionar uma classe StoreProductRequest para armazenar os novos produtos no banco de dados. Adicione a classe a seguir na parte superior do mesmo arquivo.

 public function store(StoreProductRequest $request) { $product = Product::create($request->all()); return response()->json([ 'status' => true, 'message' => "Product Created successfully!", 'product' => $product ], 200); }

Agora, você criará a solicitação, o que pode ser feito executando o seguinte comando:

 php artisan make:request StoreProductRequest

Se quiser adicionar validações, você pode usar o arquivo app/Http/Requests/StoreProductRequest.php . Para esta demonstração, não há validações.

Como criar uma rota

A etapa final antes de testar a API é adicionar uma rota. Para fazer isso, adicione o seguinte código dentro do arquivo routes/api.php . Adicione a instrução use no início do arquivo e a instrução Route no corpo:

 use App\Http\Controllers\Api\ProductController; Route::apiResource('products', ProductController::class);

Antes de começar a testar a API, certifique-se de que a tabela de produtos esteja em seu banco de dados. Se não existir, crie um usando um painel de controle como o XAMPP. Alternativamente, você pode executar o seguinte comando para migrar o banco de dados:

 php artisan migrate

Como testar uma API

Antes de testar a API, verifique se o método <code>authorize</code> dentro do app/Http/Requests/StoreProductRequest.php está definido para retornar <code>true</code>.

Agora, você pode criar um novo produto usando o Postman. Comece pressionando uma solicitação POST para este URL: http://127.0.0.1:8000/api/products/. Por se tratar de uma requisição POST para criação de um novo produto, você deve passar um objeto JSON com título e descrição.

 { "title":"Apple", "description":"Best Apples of the world" }

Depois de clicar no botão Enviar , você deverá ver o seguinte:

Agora, busque os produtos criados usando a solicitação GET . A URL é a mesma. Os resultados serão parecidos com os seguintes:

Como autenticar uma API usando o Sanctum

A autenticação é crucial ao proteger uma API. O Laravel facilita ao fornecer a funcionalidade do token Sanctum, que você pode usar como middleware. Ele protege a API usando tokens gerados quando o usuário faz login usando as credenciais corretas. Lembre-se de que os usuários não podem acessar a API segura sem um token.

O primeiro passo para adicionar autenticação é adicionar um pacote Sanctum usando o código abaixo:

 composer require laravel/sanctum

Em seguida, publique o arquivo de configuração do Sanctum:

 php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

Depois disso, adicione o token do Sanctum como middleware. Dentro do arquivo app/Http/Kernel.php , use a classe a seguir e substitua middlewareGroups pelo seguinte código na API dos grupos de middleware protegidos.

 use Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful;

 protected $middlewareGroups = [ 'web' => [ \App\Http\Middleware\EncryptCookies::class, \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class, \Illuminate\Session\Middleware\StartSession::class, // \Illuminate\Session\Middleware\AuthenticateSession::class, \Illuminate\View\Middleware\ShareErrorsFromSession::class, \App\Http\Middleware\VerifyCsrfToken::class, \Illuminate\Routing\Middleware\SubstituteBindings::class, ], 'api' => [ EnsureFrontendRequestsAreStateful::class, 'throttle:api', \Illuminate\Routing\Middleware\SubstituteBindings::class, ], ];

A próxima etapa é criar um UserController e adicionar o código para obter o token para autenticação.

 php artisan make:controller UserController

Após criar o UserController , navegue até o arquivo app/Http/Controllers/UserController.php e substitua o código existente pelo seguinte código:

 <?php namespace App\Http\Controllers; use Illuminate\Http\Request; use App\Models\User; use Illuminate\Support\Facades\Hash; class UserController extends Controller { // function index(Request $request) { $user= User::where('email', $request->email)->first(); // print_r($data); if (!$user || !Hash::check($request->password, $user->password)) { return response([ 'message' => ['These credentials do not match our records.'] ], 404); } $token = $user->createToken('my-app-token')->plainTextToken; $response = [ 'user' => $user, 'token' => $token ]; return response($response, 201); } }

Antes de poder testar a autenticação, crie um usuário empregando seeders. O comando a seguir cria um arquivo UsersTableSeeder .

 php artisan make:seeder UsersTableSeeder

Dentro do arquivo database/seeders/UsersTableSeeder.php , substitua o código existente pelo seguinte código para propagar o usuário:

 <?php namespace Database\Seeders; use Illuminate\Database\Seeder; use Illuminate\Support\Facades\DB; use Illuminate\Support\Facades\Hash; class UsersTableSeeder extends Seeder { /** * Run the database seeds. * * @return void */ public function run() { DB::table('users')->insert([ 'name' => 'John Doe', 'email' => '[email protected]', 'password' => Hash::make('password') ]); } }

Agora execute o seeder usando este comando:

 php artisan db:seed --class=UsersTableSeeder

A última etapa restante no fluxo de autenticação é usar o middleware criado para proteger a rota. Navegue até o arquivo routes/api.php e adicione a rota products dentro do middleware.

 use App\Http\Controllers\UserController; Route::group(['middleware' => 'auth:sanctum'], function () { Route::apiResource('products', ProductController::class); }); Route::post("login",[UserController::class,'index']);

Depois de adicionar uma rota ao middleware, você receberá um erro interno do servidor se tentar buscar os produtos.

Mas assim que você fizer login, obter um token e usá-lo no cabeçalho, ele o autenticará e começará a funcionar. Você pode enviar uma solicitação POST para http://127.0.0.1:8000/api/login com o seguinte corpo:

 { "email":"[email protected]", "password":"password" }

Use o token recebido como um token de portador e adicione-o como o cabeçalho de autorização.

Como lidar com erros de API

Sempre que você envia uma solicitação ao servidor, ele responde. Com a resposta, também envia um código de status de acordo com a natureza da resposta. Por exemplo, um código de status 200 indica que a solicitação foi bem-sucedida e um 404 sugere que o servidor não pode encontrar o recurso solicitado.

No entanto, um código de status não é suficiente. É necessária uma mensagem de erro legível por humanos. O Laravel vem com muitas maneiras de lidar com erros. Você pode usar um bloco try-catch, o método de fallback ou enviar uma resposta personalizada. O código a seguir adicionado ao UserController demonstra isso.

 if (!$user || !Hash::check($request->password, $user->password)) { return response([ 'message' => ['These credentials do not match our records.'] ], 404); }

Resumo

O modelo Eloquent do Laravel torna fácil criar, validar e testar APIs. Seu mapeamento objeto-relacional fornece uma abordagem direta para interagir com o banco de dados.

Além disso, atuando como middleware, o token Sanctum do Laravel pode ajudá-lo a proteger suas APIs rapidamente.

E se você precisar de mais otimização, a solução de hospedagem de banco de dados da Kinsta simplifica a configuração e o gerenciamento de bancos de dados para todos os seus projetos da web.