Petición HTTP

Definición

Una petición HTTP es un mensaje enviado desde un cliente (navegador, aplicación móvil, consumidor de API) a un servidor para solicitar un recurso específico o disparar una acción. Cada interacción web comienza con una petición HTTP.

La petición consiste en tres partes principales:

Línea de Petición - Método, URI y versión HTTP
Cabeceras - Metadatos sobre la petición (autenticación, tipo de contenido, etc.)
Cuerpo (opcional) - Carga de datos para métodos como POST, PUT, PATCH

Las peticiones HTTP siguen un formato estricto definido en RFC 7231 y son la base de las APIs RESTful y la comunicación web.

Ejemplo

Una petición HTTP GET típica para recuperar datos de usuario:

GET /api/users/123 HTTP/1.1
Host: api.example.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
Accept: application/json
User-Agent: Mozilla/5.0

Una petición POST para crear un nuevo recurso:

POST /api/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
Content-Length: 89

{
  "name": "Alice Smith",
  "email": "[email protected]",
  "role": "developer"
}

Ejemplo de Código

JavaScript (Fetch API):

// Petición GET
const getUser = async (userId) => {
  const response = await fetch(`https://api.example.com/users/${userId}`, {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_TOKEN',
      'Accept': 'application/json'
    }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  return await response.json();
};

// Petición POST
const createUser = async (userData) => {
  const response = await fetch('https://api.example.com/users', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_TOKEN'
    },
    body: JSON.stringify(userData)
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  return await response.json();
};

// Uso
const newUser = {
  name: 'Alice Smith',
  email: '[email protected]',
  role: 'developer'
};

createUser(newUser)
  .then(user => console.log('Created:', user))
  .catch(error => console.error('Error:', error));

Python (librería requests):

import requests

# Petición GET
def get_user(user_id):
    response = requests.get(
        f'https://api.example.com/users/{user_id}',
        headers={
            'Authorization': 'Bearer YOUR_TOKEN',
            'Accept': 'application/json'
        }
    )
    response.raise_for_status()
    return response.json()

# Petición POST
def create_user(user_data):
    response = requests.post(
        'https://api.example.com/users',
        json=user_data,
        headers={
            'Authorization': 'Bearer YOUR_TOKEN'
        }
    )
    response.raise_for_status()
    return response.json()

# Uso
new_user = {
    'name': 'Alice Smith',
    'email': '[email protected]',
    'role': 'developer'
}

try:
    user = create_user(new_user)
    print(f'Created: {user}')
except requests.exceptions.HTTPError as e:
    print(f'Error: {e}')

Diagrama

sequenceDiagram
    participant Client
    participant Server

    Note over Client: Preparar Petición
    Client->>Client: Establecer Método (GET/POST/etc)
    Client->>Client: Añadir Cabeceras
    Client->>Client: Añadir Cuerpo (si es necesario)

    Note over Client,Server: Enviar Petición
    Client->>Server: Petición HTTP
    Note right of Server: Línea de Petición
Cabeceras
Cuerpo (opcional)

    Note over Server: Procesar Petición
    Server->>Server: Validar
    Server->>Server: Autenticar
    Server->>Server: Ejecutar Lógica

    Note over Client,Server: Enviar Respuesta
    Server->>Client: Respuesta HTTP
    Note left of Client: Código de Estado
Cabeceras
Cuerpo

    Note over Client: Manejar Respuesta
    Client->>Client: Parsear Respuesta
    Client->>Client: Actualizar UI/Estado

Analogía

Piensa en una petición HTTP como ordenar en un restaurante:

Línea de Petición → “Me gustaría la ensalada César” (qué quieres)
Cabeceras → “Sin picatostes, aderezo aparte” (preferencias/metadatos)
Cuerpo → Instrucciones personalizadas escritas en una nota (datos adicionales)

El camarero (servidor) toma tu pedido (petición), lo procesa en la cocina y trae tu comida (respuesta).

Mejores Prácticas

Usar Método HTTP Correcto - GET para lecturas, POST para creación, PUT/PATCH para actualizaciones, DELETE para eliminación
Incluir Cabeceras Requeridas - Host, Content-Type, Authorization cuando sea necesario
Establecer Timeouts - Siempre configurar timeouts de petición para prevenir conexiones colgadas
Manejar Errores Graciosamente - Verificar códigos de estado y manejar fallos de red
Usar HTTPS - Siempre encriptar datos sensibles en tránsito
Validar Entrada - Sanitizar datos antes de enviarlos en el cuerpo de la petición
Establecer User-Agent - Identificar tu cliente para logs del servidor y analíticas

Errores Comunes

Content-Type Faltante - Enviar JSON sin cabecera Content-Type: application/json
Método HTTP Incorrecto - Usar GET con cuerpo, o POST cuando GET es apropiado
Sin Manejo de Errores - No verificar códigos de estado de respuesta o errores de red
URLs Hardcodeadas - No usar variables de entorno para endpoints de API
Enviar Secretos en URLs - Nunca poner claves API o tokens en parámetros de consulta
Olvidar Cabeceras CORS - No establecer cabeceras apropiadas para peticiones cross-origin
Sin Lógica de Reintento - No implementar backoff exponencial para fallos transitorios