Beruflich Dokumente
Kultur Dokumente
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
$ cd laravel-api
$ php artisan serve
Laravel development server started: http://127.0.0.1:8000
NETIREKI Ricardo Otxoa
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=********
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 }
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:
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 }
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 }
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 }
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 });
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 }
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');
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.
[GET] http://localhost:8000/api/articles/
NETIREKI Ricardo Otxoa
[GET] http://localhost:8000/api/articles/12
NETIREKI Ricardo Otxoa
[POST] http://localhost:8000/api/articles/
Deberemos añadir los pares clave-valor para ‘title‘ y ‘body‘ en el apartado “Body”.
NETIREKI Ricardo Otxoa
[PUT] http://localhost:8000/api/articles/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