Sie sind auf Seite 1von 20

 NETIREKI Ricardo Otxoa

CREAR UNA REST API CON


AUTENTICACIÓN USANDO
LARAVEL
[CAPÍTULO 1]

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su
consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies.

ACEPTAR
 NETIREKI Ricardo Otxoa

OBJETIVO
Esta entrada es la primera de una serie de artículos sobre LARAVEL, uno de los
frameworks PHP más populares del momento.
El objetivo de estos artículos es aprender a construir una REST API con autenticación
usando LARAVEL 5.5. Para ello utilizaremos COMPOSER, el gestor de paquetes y
dependencias de PHP, y ARTISAN , una interfaz de línea de comandos que viene con
LARAVEL.
La API que vamos a crear nos permitirá la creación, consulta, actualización y borrado de
 NETIREKI Ricardo Otxoa
Usuarios y Artículos, y que estas acciones solo sean realizadas a través de llamadas
autenticadas (de usuarios inicialmente registrados en el sistema):

Artículo:

Título
Cuerpo
Fecha de publicación

Usuario:

Nombre
Correo electrónico
Contraseña

Todo el código necesario para seguir esta guía y construir la REST API se encuentra en
GITHUB.

CONTENIDO
En este primer artículo abordaremos los siguientes puntos:

PRERREQUISITOS
PASO 1: CONFIGURACIÓN BÁSICA DE UNA APLICACIÓN LARAVEL
PASO 2: CONECTAR CON LA BASE DE DATOS
PASO 3: POBLANDO LAS TABLAS DE ARTÍCULOS Y USUARIOS
PASO 4: RUTAS Y CONTROLADORES CRUD
PASO 5: PROBANDO LA API CON POSTMAN
RECOPILACIÓN

PRERREQUISITOS
PHP
Composer
MySQL
 NETIREKI Ricardo Otxoa
Postman

PASO 1: CONFIGURACIÓN BÁSICA DE UNA APLICACIÓN LARAVEL


Desde la línea de comandos, nos situamos en nuestr directorio de proyectos e
instalamos LARAVEL usando el siguiente comando de COMPOSER:

$ composer global require laravel/installer

Creamos la estructura de la nueva aplicación LARAVEL tecleando lo siguiente:

$ composer create-project --prefer-dist laravel/laravel laravel-api

Y con esto ya somos capaces de arrancar el servidor y comprobar si la aplicación


funciona:

$ cd laravel-api
$ php artisan serve
Laravel development server started: http://127.0.0.1:8000
 NETIREKI Ricardo Otxoa

Laravel – Pantalla de inicio

PASO 2: CONECTAR CON LA BASE DE DATOS


Al crear la estructura de la aplicación, en el directorio de proyectos donde estamos
trabajando se habrá creado una nueva carpeta “laravel-api” con la siguiente estructura:
 NETIREKI Ricardo Otxoa

Laravel – Estructura de directorios

Debemos introducir las credenciales para que la aplicación pueda acceder a la base de
datos (que deberemos tener creada previamente). Esto lo haremos editando el fichero
.env que se encuentra en el directorio raíz de la aplicación:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravelapi
DB_USERNAME=username
DB_PASSWORD=********

Para construir el modelo de datos de los Artículos y la migración asociada, usaremos el


siguiente comando de ARTISAN :
 NETIREKI Ricardo Otxoa
$ php artisan make:model Article -m

La opción -m es la abreviatura de –migration, que le indica a ARTISAN que la cree


automáticamente para nuestro modelo.
Las MIGRACIONES EN LARAVEL actúan a modo de control de versiones de la base de datos, y
resulta muy útil para modificar y compartir el esquema de datos de la aplicación.
LARAVEL viene por defecto con dos migraciones, creates_users_table y
create_passwords_reset_table. Esta última no la vamos a aprovechar, pero users nos va
a ser muy útil en esta guía.
La nueva migración se generará en el directorio ./laravel-api/database/migrations

1 use Illuminate\Support\Facades\Schema;
2 use Illuminate\Database\Schema\Blueprint;
3 use Illuminate\Database\Migrations\Migration;
4
5 class CreateArticlesTable extends Migration
6 {
7 /**
8 * Run the migrations.
9 *
10 * @return void
11 */
12 public function up()
13 {
14 Schema::create('articles', function (Blueprint $table) {
15 $table->increments('id');
16 $table->timestamps();
17 });
18 }
19
20 /**
21 * Reverse the migrations.
22 *
23 * @return void
24 */
25 public function down()
26 {
27 Schema::dropIfExists('articles');
28 }
29 }

2017_10_27_114127_create_articles_table.php hosted with by GitHub view raw


Vamos a añadir los campos Título y Cuerpo al modelo editando la función up():
 NETIREKI Ricardo Otxoa
1 public function up()
2 {
3 Schema::create('articles', function (Blueprint $table) {
4 $table->increments('id');
5 $table->string('title');
6 $table->text('body');
7 $table->timestamps();
8 });
9 }

2017_10_27_114127_create_articles_table hosted with by GitHub view raw

El método string crea una columna de tipo VARCHAR, mientras que text genera una de tipo TEXT.

Para que estos cambios se vean reflejados en nuestra vase de datos, lanzamos el
siguiente comando:

$ php artisan migrate

Volvemos a nuestro modelo, y vamos a indicar qué campos de un Artículo son editables.
Para ello usaremos el campo $fillable en la clase Article que se ha generado
automáticamente en ./laravel-api/app/Article.php:

1 namespace App;
2
3 use Illuminate\Database\Eloquent\Model;
4
5 class Article extends Model
6 {
7 protected $fillable = ['title', 'body'];
8 }

Article.php hosted with by GitHub view raw

PASO 3: POBLANDO LAS TABLAS DE ARTÍCULOS Y USUARIOS


Vamos a poblar o sembrar (‘seed‘ en inglés) las tablas con datos de prueba para poder
 NETIREKI Ricardo Otxoa
testear nuestra aplicación. LARAVEL trae FAKER, una librería que nos ayuda en esta tarea.
Para crear nuestra primera siembra:

$ php artisan make:seeder ArticlesTableSeeder

Al finalizar este comando, tendremos un nuevo fichero en ./laravel-


api/database/seeds/ArticlesTableSeeder.php. Lo editamos para darle algo de
funcionalidad y que nos quede con este aspecto:

1 use App\Article;
2 use Illuminate\Database\Seeder;
3
4 class ArticlesTableSeeder extends Seeder
5 {
6 /**
7 * Run the database seeds.
8 *
9 * @return void
10 */
11 public function run()
12 {
13 // Let's truncate our existing records to start from scratch.
14 Article::truncate();
15
16 $faker = \Faker\Factory::create();
17
18 // And now, let's create a few articles in our database:
19 for ($i = 0; $i < 50; $i++) {
20 Article::create([
21 'title' => $faker->sentence,
22 'body' => $faker->paragraph,
23 ]);
24 }
25 }
26 }

ArticlesTableSeeder.php hosted with by GitHub view raw

Ejecutamos el comando seed para realizar la siembra:


 NETIREKI Ricardo Otxoa
$ php artisan db:seed --class=ArticlesTableSeeder

Y si inspeccionamos el contenido de la tabla en la base de datos, veremos que ya


cuenta con 50 líneas:

Tabla de Artículos tras la siembra

Repetimos el proceso para los Usuarios, primero creando la siembra:

$ php artisan make:seeder UsersTableSeeder

A continuación preparamos el código para sembrar Usuarios:

1 use App\User;
2 use Illuminate\Database\Seeder;
 NETIREKI Ricardo Otxoa
3
4 class UsersTableSeeder extends Seeder
5 {
6 /**
7 * Run the database seeds.
8 *
9 * @return void
10 */
11 public function run()
12 {
13 // Let's clear the users table first
14 User::truncate();
15
16 $faker = \Faker\Factory::create();
17
18 // Let's make sure everyone has the same password and
19 // let's hash it before the loop, or else our seeder
20 // will be too slow.
21 $password = Hash::make('netireki');
22
23 User::create([
24 'name' => 'Admin',
25 'email' => 'admin@test.com',
26 'password' => $password,
27 ]);
28
29 // And now let's generate a few dozen users for our app:
30 for ($i = 0; $i < 10; $i++) {
31 User::create([
32 'name' => $faker->name,
33 'email' => $faker->email,
34 'password' => $password,
35 ]);
36 }
37 }
38 }

UsersTableSeeder.php hosted with by GitHub view raw

Y luego ejecutando la siembra:

$ php artisan db:seed --class=UsersTableSeeder


Y como resultado, observamos en la base de datos qué tal ha ido la cosecha:
 NETIREKI Ricardo Otxoa

Tabla de Usuarios tras la siembra

PASO 4: RUTAS Y CONTROLADORES CRUD


En los pasos anteriores hemos generado una aplicación esqueleto con LARAVEL, la
hemos conectado a la base de datos y hemos poblado sus tablas a través de varias
siembras.
En este cuarto paso vamos a dotar a nuestra aplicación de la clásica funcionalidad
CRUD: crear (Create), recuperar (Retrieve), actualizar (Update) y borrar (Delete) items de
la base de datos.
En primer lugar vamos a implementar las rutas, que serán las URL que se enviarán a
nuestra aplicación para implementar cada una de las operaciones descritas. Con LARAVEL
es tan sencillo como editar el fichero ./laravel-api/routes/api.php:

1 Use App\Article;
2
3 Route::get('articles', function() {
4 // If the Content-Type and Accept headers are set to 'application/json',
5 // this will return a JSON structure. This will be cleaned up later.
6 return Article::all();
7 });
8
9 Route::get('articles/{id}', function($id) {
10 return Article::find($id);
11 });
12
13 Route::post('articles', function(Request $request) {
 NETIREKI Ricardo Otxoa
14 return Article::create($request->all);
15 });
16
17 Route::put('articles/{id}', function(Request $request, $id) {
18 $article = Article::findOrFail($id);
19 $article->update($request->all());
20
21 return $article;
22 });
23
24 Route::delete('articles/{id}', function($id) {
25 Article::find($id)->delete();
26
27 return 204;
28 });

api.php hosted with by GitHub view raw

Vamos a mover este código a su propio controlador. Generamos el controlador con el


siguiente comando de ARTISAN :

$ php artisan make:controller ArticleController

Y copiamos el código en el fichero generado ./laravel-


api/app/Http/Controllers/ArticleController.php:

1 namespace App\Http\Controllers;
2
3 Use App\Article;
4 use Illuminate\Http\Request;
5
6 class ArticleController extends Controller
7 {
8
9 public function index()
10 {
11 return Article::all();
12 }
13
14 public function show(Article $article)
15 {
16 return $article;
17 }
 NETIREKI Ricardo Otxoa
18
19 public function store(Request $request)
20 {
21 $article = Article::create($request->all());
22
23 return response()->json($article, 201);
24 }
25
26 public function update(Request $request, Article $article)
27 {
28 $article->update($request->all());
29
30 return response()->json($article, 200);
31 }
32
33 public function delete(Article $article)
34 {
35 $article->delete();
36
37 return response()->json(null, 204);
38 }
39 }

ArticleController.php hosted with by GitHub view raw

De tal forma que el fichero ./laravel-api/Routes/api.php nos quedará de esta manera,


indicando para cada ruta el controlador y método que deben llamarse:

1 Route::get('articles', 'ArticleController@index');
2 Route::get('articles/{article}', 'ArticleController@show');
3 Route::post('articles', 'ArticleController@store');
4 Route::put('articles/{article}', 'ArticleController@update');
5 Route::delete('articles/{article}', 'ArticleController@delete');

api.php hosted with by GitHub view raw

Los métodos del controlador retornan datos en formato JSON y un código HTTP para
que lo procese la aplicación cliente. Estos son algunos de los códigos HTTP de retorno
más comunes:

200: OK. Código estandar de que todo ha ido bien y opción por defecto.
201: Object created. Muy útil para las operaciones de guardado.
204: No content. Cuando una acción se ejecuta con éxito, pero no hay contenido
 NETIREKI Ricardo Otxoa
que devolver.
206: Partial content. Útil cuando se devuelven resultados paginados.
400: Bad request. Respuesta estándar cuando una petición no supera la validación.
401: Unauthorized. Autenticación requerida.
403: Forbidden. El usuario se ha autenticado, pero no tiene los permisos necesarios
para realizar la acción.
404: Not found. Laravel lo devuelve automáticamente cuando no se encuentra un
recurso.
500: Internal server error. Nunca debería retornarse este valor explícitamente, pero
si algo inesperado falla, esta es la respuesta que recibirá el usuario.
503: Service unavailable. Bastante descriptivo por sí mismo. Nuestra aplicación
tampoco debería devolver explícitamente este código.

PASO 5: PROBANDO LA API CON POSTMAN


Siguiendo las instrucciones de estos 4 pasos ya tenemos una API que nos permite hacer
la gestión básica de Artículos. Si queremos verla en acción, para probarla y ver que todo
funciona correctamente, podemos usar POSTMAN .
POSTMAN es una potente herramienta para probar API’s con una interfaz gráfica muy
intuitiva y sencilla de manejar. Una forma sencilla de empezar con POSTMAN es instalar la
extensión para Chrome, aunque es recomendable instalar la aplicación nativa para
nuestro sistema operativo ya que la extensión ha sido descontinuada recientemente.
Una vez arrancada la herramienta, su uso es tan sencillo como ir introduciendo URL’s en
la barra de direcciones que contiene, e ir cambiando el método en el desplegable que
usa a su izquierda para alternar entre peticiones GET, POST, PUT y DELETE (por poner
las más comunes).
Así, si queremos recuperar todos los Artículos de la base de datos, hacemos la siguiente
llamada a nuestra API con el método GET, tal como lo hemos configurado en nuestras
rutas y controladores en el paso 4:

[GET] http://localhost:8000/api/articles/
 NETIREKI Ricardo Otxoa

Postman – Recuperar todos los Artículos [GET]

Podemos testear el resto de rutas:

Recuperar el artículo con identificador 12:

[GET] http://localhost:8000/api/articles/12
 NETIREKI Ricardo Otxoa

Postman – Recuperar un Artículo [GET]

Crear un nuevo artículo:

[POST] http://localhost:8000/api/articles/

Deberemos añadir los pares clave-valor para ‘title‘ y ‘body‘ en el apartado “Body”.
 NETIREKI Ricardo Otxoa

Postman – Crear un Artículo [POST]

Actualizar el título del artículo con identificador 51:

[PUT] http://localhost:8000/api/articles/51

Deberemos añadir el par clave-valor en el apartado “Body”.


 NETIREKI Ricardo Otxoa

Postman – Actualizar un Artículo [PUT]

Borrar el artículo con identificador 51:

[DELETE] http://localhost:8000/api/articles/51
 NETIREKI Ricardo Otxoa

Postman – DELETE

RECOPILACIÓN
En este primer artículo de la serie “Crear una REST API con autenticación usando
Laravel” hemos aprendido a crear la estructura básica de una aplicación LARAVEL, a
conectarla con una base de datos, a poblar las tablas y a implementar las rutas y
controladores básicos para soportar una operativa CRUD básica.
Para ello hemos utilizado herramientas como COMPOSER, el gestor de paquetes y
dependencias para PHP, una potente interfaz de línea de comandos de LARAVEL, y
POSTMAN , una herramienta muy útil para testear REST API’s.
En los siguientes artículos veremos cómo implementar autenticación vía API con
LARAVEL, rutas y controladores para registrar y logear usuarios, así como el uso de
middlewares para restringir el acceso a la API.
Si tienes cualquier duda o problema a la hora de comprender alguno de los pasos,
exponla en los comentarios y te responderé. Y si ya tienes experiencia haciendo REST

Das könnte Ihnen auch gefallen