Configuración de una Aplicación Rails Solo API

En el mundo del desarrollo web, Ruby on Rails se ha consolidado como un framework poderoso y versátil. Aunque tradicionalmente se ha utilizado para construir aplicaciones web completas, también es posible crear aplicaciones que sirvan únicamente como API. En este artículo, te guiaré a través del proceso de configuración de una aplicación Rails solo API, desde la instalación hasta la creación de tus primeros endpoints.

¿Qué es una API?

Una API (Interfaz de Programación de Aplicaciones) es un conjunto de reglas y protocolos que permiten que diferentes aplicaciones se comuniquen entre sí. En el contexto de una aplicación web, una API permite que el frontend (la parte visible para el usuario) se comunique con el backend (la parte que maneja la lógica y los datos).

¿Por qué usar Rails para una API?

Ruby on Rails es conocido por su rapidez y facilidad de uso. Algunas de las ventajas de usar Rails para construir una API incluyen:

Desarrollo rápido: Rails sigue el principio de "convención sobre configuración", lo que significa que muchas decisiones ya están tomadas por el framework, permitiéndote centrarte en la lógica de tu aplicación.
Soporte para JSON: Rails tiene soporte nativo para JSON, lo que facilita la creación de APIs que devuelven datos en este formato.
Gran comunidad: La comunidad de Rails es activa y hay muchos recursos disponibles para ayudarte a resolver problemas.

Requisitos Previos

Antes de comenzar, asegúrate de tener instalado lo siguiente en tu máquina:

Ruby: Asegúrate de tener Ruby instalado. Puedes verificarlo ejecutando ruby -v en tu terminal.
Rails: Instala Rails si aún no lo tienes. Puedes hacerlo con el siguiente comando:

gem install rails

Base de datos: Necesitarás una base de datos. Rails soporta varias, pero para este tutorial usaremos SQLite por su simplicidad.

Creando una Nueva Aplicación Rails Solo API

Ahora que tienes todo lo necesario, vamos a crear nuestra nueva aplicación Rails. Abre tu terminal y ejecuta el siguiente comando:

rails new mi_api --api

El flag --api le indica a Rails que queremos crear una aplicación optimizada para API. Esto significa que se generarán solo los componentes necesarios para una API, omitiendo vistas y otros elementos que no son necesarios.

Configurando la Base de Datos

Una vez que se ha creado la aplicación, navega al directorio de tu nueva aplicación:

cd mi_api

Ahora, abre el archivo config/database.yml y asegúrate de que la configuración de la base de datos sea la que deseas. Para este tutorial, la configuración predeterminada de SQLite debería ser suficiente.

Para crear la base de datos, ejecuta el siguiente comando:

rails db:create

Creando un Modelo y un Controlador

Ahora que nuestra base de datos está configurada, vamos a crear un modelo y un controlador. Supongamos que queremos crear una API para gestionar una lista de tareas. Primero, generaremos un modelo llamado Task:

rails generate model Task title:string completed:boolean

Esto generará un modelo Task con dos atributos: title (cadena de texto) y completed (booleano). Ahora, ejecuta la migración para crear la tabla en la base de datos:

rails db:migrate

A continuación, generaremos un controlador para manejar las solicitudes relacionadas con las tareas:

rails generate controller Tasks

Definiendo Rutas

Ahora que tenemos nuestro modelo y controlador, necesitamos definir las rutas para nuestra API. Abre el archivo config/routes.rb y agrega lo siguiente:

Rails.application.routes.draw do
  resources :tasks
end

Esto creará las rutas RESTful estándar para el recurso Task, incluyendo los métodos index, show, create, update y destroy.

Implementando Acciones en el Controlador

Ahora, vamos a implementar las acciones en nuestro controlador TasksController. Abre el archivo app/controllers/tasks_controller.rb y agrega el siguiente código:

class TasksController < ApplicationController
  def index
    @tasks = Task.all
    render json: @tasks
  end

  def show
    @task = Task.find(params[:id])
    render json: @task
  end

  def create
    @task = Task.new(task_params)
    if @task.save
      render json: @task, status: :created
    else
      render json: @task.errors, status: :unprocessable_entity
    end
  end

  def update
    @task = Task.find(params[:id])
    if @task.update(task_params)
      render json: @task
    else
      render json: @task.errors, status: :unprocessable_entity
    end
  end

  def destroy
    @task = Task.find(params[:id])
    @task.destroy
    head :no_content
  end

  private

  def task_params
    params.require(:task).permit(:title, :completed)
  end
end

En este código, hemos definido las acciones para manejar las solicitudes a nuestra API. Cada acción interactúa con el modelo Task y devuelve datos en formato JSON.

Probando la API

Para probar nuestra API, podemos usar herramientas como Postman o cURL. A continuación, te muestro algunos ejemplos de cómo hacer solicitudes a nuestra API usando cURL:

Obtener todas las tareas:

curl -X GET http://localhost:3000/tasks

Crear una nueva tarea:

curl -X POST http://localhost:3000/tasks -H "Content-Type: application/json" -d '{"task": {"title": "Nueva tarea", "completed": false}}'

Actualizar una tarea:

curl -X PATCH http://localhost:3000/tasks/1 -H "Content-Type: application/json" -d '{"task": {"completed": true}}'

Eliminar una tarea:

curl -X DELETE http://localhost:3000/tasks/1

Conclusión

En este artículo, hemos cubierto los pasos básicos para configurar una aplicación Rails solo API. Desde la creación de la aplicación hasta la implementación de un modelo y controlador, ahora tienes una base sólida para construir tu propia API. Recuerda que Rails ofrece muchas más características y funcionalidades que puedes explorar para mejorar tu API, como la autenticación, la paginación y la documentación automática.

¡Feliz codificación!