Creando una Web API

Search…
Creando una Web API
A través de un Web API puedes permitir a otras aplicaciones interactuar con tu aplicación.
API, por las siglas en Inglés Application Programming Interface es, en general, una forma en que un software interactúa con otro software, no necesariamente a través de HTTP. Por ejemplo, a través del API de jQuery puedes realizar todo tipo de cosas interesantes en el navegador.
Un Web API es un tipo de API que utiliza el protocolo HTTP como forma de comunicación.
Todo lo que has visto hasta ahora te sirve para crear tus propias Web API's, la única diferencia es que en vez de recibir información de formularios y renderizar HTML, ahora nuestros controladores van a recibir y retornar JSON.
Nuestro primer endpoint
A las URL's que van exponer funcionalidad de nuestra aplicación se les llama endpoints.
Por ejemplo, el siguiente controlador permite listar los artículos:
1
class ArticlesController < ApplicationController
2
  def index
3
    articles = Articles.all
4
    render json: articles
5
  end
6
end
Copied!
La línea más importante de este código es render json: articles que retorna los artículos en formato JSON en vez de renderizar una vista normal.
Nuestro archivo config/routes.rb tendría configurada la ruta de la siguiente forma:
1
Rails.application.routes.draw do
2
  resources :tasks, only: [:index]
3
end
Copied!
Fíjate que esto es igual a lo que ya habías visto antes. La única diferencia es retornar JSON en vez de renderizar la vista.
Probando nuestro primer endpoint
Puedes probar este primer endpoint de varias formas:
1.Utilizando curl, que es una aplicación de la línea de comandos para hacer peticiones HTTP.
2.Descargando Postman, que es una aplicación gráfica para hacer peticiones HTTP.
3.Haciendo la petición HTTP desde cualquier lenguaje de programación. En Ruby puedes utilizar una gema llamada HTTParty.
4.Cuando estás haciendo llamados GET puedes utilizar el navegador e ingresar la URL.
Veamos cada una de ellas.
Curl
Curl viene instalado en la mayoría de distribuciones de Linux y en Mac. Si estás en Windows deberás instalarlo o utilizar alguna de las otras alternativas que vamos a ver.
Para hacer una petición a nuestro endpoint deberás abrir otra ventana de la consola (recuerda que debes tener prendido el servidor) y ejecutar el siguiente comando:
1
$ curl http://localhost:3000/articles
Copied!
El resultado puede variar dependiendo de los registros que tengas en tu aplicación, pero deberás ver una respuesta similar a la siguiente:
1
[{"id":1,"title":"Artículo 1","body":"Cuerpo del artículo","published":false,"created_at":"2017-07-09T19:54:42.257Z","updated_at":"2017-07-09T19:54:42.257Z"},{"id":2,"title":"Artículo 2","body":"Cuerpo del artículo","published":true,"created_at":"2017-07-09T19:54:56.582Z","updated_at":"2017-07-09T19:54:56.582Z"}]
Copied!
Postman
Una vez que has descargado e instalado Postman puedes realizar una petición HTTP como se ven en la siguiente imagen:
Postman
HTTParty
Primero debes descargar la gema ejecutando:
1
$ gem install httparty
Copied!
Después abre IRB y ejecuta lo siguiente:
1
$ irb
2
> require 'httparty'
3
 => true
4
> response = HTTParty.get("http://localhost:3000/articles")
5
  => ...
6
> response.parsed_response
7
 => [{"id"=>1, "title"=>"Artículo 1", "body"=>"Cuerpo del artículo", "published"=>false, "created_at"=>"2017-07-09T19:54:42.257Z", "updated_at"=>"2017-07-09T19:54:42.257Z"}, {"id"=>2, "title"=>"Artículo 2", "body"=>"Cuerpo del artículo", "published"=>true, "created_at"=>"2017-07-09T19:54:56.582Z", "updated_at"=>"2017-07-09T19:54:56.582Z"}]
Copied!
Con el navegador
Como nuestro endpoint sólo retorna JSON puedes abrir en tu navegador la URL http://localhost:3000/articles y verás la respuesta en formato JSON.
Browser
Sin embargo, esto sólo es posible para llamados GET.
Completando el API
Veamos ahora los endpoints de crear, editar y eliminar artículos:
1
class ArticlesController < ApplicationController
2
  protect_from_forgery with: :null_session
3
​
4
  def index
5
    articles = Article.all
6
    render json: articles
7
  end
8
​
9
  def create
10
    article = Article.new(article_params)
11
    if article.save
12
      render json: article
13
    else
14
      render json: { errors: article.errors }, status: 422
15
    end
16
  end
17
​
18
  def update
19
    article = Article.find(params[:id])
20
    if article.update(article_params)
21
      render json: article
22
    else
23
      render json: { errors: article.errors }, status: 422
24
    end
25
  end
26
​
27
  def destroy
28
    article = Article.find(params[:id])
29
    article.destroy
30
​
31
    head :no_content
32
  end
33
​
34
  private
35
    def article_params
36
      params.require(:article).permit(:title, :body, :published)
37
    end
38
end
Copied!
Fíjate la línea protect_from_forgery with: :null_session al principio de la clase. Esto es importante para que Rails no haga la verificación normal sobre los formularios y nos permita crear y editar artículos.
En config/routes.rb configuraríamos nuestras rutas así:
1
Rails.application.routes.draw do
2
  resources :articles, only: [:index, :create, :update, :destroy]
3
end
Copied!
Eso va a crear los siguientes endpoints:
1
GET /articles
2
POST /articles
3
PATCH /articles/:id
4
DELETE /articles/:id
Copied!
El primer endpoint lo probamos anteriormente de varias formas, veamos cómo podemos ahora probar los demás desde HTTParty.
Para crear un nuevo artículo podemos hacer la siguiente petición:
1
HTTParty.post("http://localhost:3000/articles",
2
    body: { title: "Otro artículo", body: "El cuerpo", published: true }.to_json,
3
    headers: { "Content-Type" => "application/json" })
Copied!
Para editar un artículo podemos hacer la siguiente petición asumiendo que existe el artículo con id 1:
1
HTTParty.patch("http://localhost:3000/articles/1",
2
    body: { title: "Cambia", body: "Cambia el cuerpo", published: true }.to_json,
3
    headers: { "Content-Type" => "application/json" })
Copied!
Para eliminar un artículo podemos hacer la siguiente petición asumiendo que existe el artículo con id 1:
1
HTTParty.delete("http://localhost:3000/articles/1")
Copied!
Autenticación
Existen varias formas de asegurar un API pero una de las más comunes y fáciles de implementar es HTTP Basic, que fue una de las primeras formas de autenticación en la Web.
Ruby on Rails incluye un método llamado authenticate_or_request_with_http_basic para implementar HTTP Basic. Por ejemplo, podemos asegurar un controlador de la siguiente forma:
1
class ProductsController < ApplicationController
2
  before_action :basic_auth
3
​
4
  # acá van todas las acciones
5
​
6
  private
7
    def basic_auth
8
      authenticate_or_request_with_http_basic do |user, password|
9
        # Verificar user y password. Por ejemplo (aunque no lo recomendamos):
10
        user == "german" && password == "test1234"
11
      end
12
    end
13
end
Copied!
En la línea 2 agregamos un before_action que va a ejecutar el método basic_auth antes de cada acción.
En la línea 7 estamos definiendo el método que hace uso de authenticate_or_request_with_http_basic para verificar el usuario y la contraseña.
La línea 9 es la que hace la validación. Sin embargo, en este ejemplo tenemos quemados los valores del usuario y la contraseña, más adelante vamos a ver cómo integrar Devise.
Si la autenticación falla se va a retornar un código 401 Unauthorized.
HTTP Basic utiliza un encabezado llamado Authorization que incluye el nombre de usuario y el password en Base64. Por ejemplo:
1
Authorization: Basic QWxhZGRpbjpPcGVuU2VzYW1l
Copied!
Aunque es posible generar este encabezado manualmente, la mayoría de herramientas y librerías HTTP ofrecen algún mecanismo para incluir las credenciales y generar el encabezado. Por ejemplo, en curl se utiliza la opción --user o -u:
1
$ curl --user german:test1234 http://localhost:3000/products
Copied!
Integración con Devise
Puedes autenticar a los usuarios de Devise por HTTP Basic como lo explican en este artículo.
Sin embargo, como decíamos anteriormente, no es buena idea utilizar la misma contraseña Web para el API. Una opción es utilizar una gema como devise_token_auth o puedes implementarlo tu mismo(a) siguiendo estos pasos:
1.Debemos agregar un campo auth_token al modelo de Devise. Por ejemplo:
1
 $ rails g migration add_auth_token_to_users auth_token
Copied!
2.En el modelo User debemos generar el token cuando se crea el usuario utilizando un método que incluye Rails llamado has_secure_token:
1
 class User < ApplicationRecord
2
   has_secure_token :auth_token
3
​
4
   ...
5
 end
Copied!
3.Implementar el método que hace la verificación en ApplicationController (de esa forma lo podemos utilizar desde varios controladores)
1
 def basic_auth
2
   authenticate_or_request_with_http_basic do |username, token|
3
     user = User.find_by_email(username)
4
     if user.auth_token == token
5
       sign_in user
6
     end
7
   end
8
 end
Copied!
Testing en Rails
Web Sockets
Last modified 4yr ago
Copy link
Contents
Nuestro primer endpoint
Probando nuestro primer endpoint
Integración con Devise