Cómo implementar la lógica de redireccionamiento en el servidor - Probably Peter

La implementación de la lógica de redireccionamiento en el servidor suele implicar el envío de un código de estado HTTP específico y un Location encabezado al cliente. Cuando un navegador recibe esta respuesta, navega automáticamente a la URL especificada en el Location encabezado.

A continuación se detallan los métodos más comunes y las consideraciones a tener en cuenta:

1. Códigos de estado HTTP para redireccionamientos

Los códigos de estado HTTP más comunes para las redirecciones son:

301 Movido permanentemente: indica que el recurso se ha trasladado de forma permanente a una nueva URL. Los motores de búsqueda actualizarán sus índices con la nueva URL, y los clientes deben almacenar esta redirección en caché.
302 Encontrado (o Movido temporalmente): indica que el recurso está disponible temporalmente en una URL diferente. Los motores de búsqueda no suelen actualizar sus índices, y los clientes no deben almacenar esta redirección en caché.
307 Redireccionamiento temporal: este es el sucesor de 302 en HTTP/1.1. Indica explícitamente que el método de solicitud no debe cambiarse al redirigir.

Para la mayoría de las redirecciones permanentes, se prefiere el 301 por motivos de SEO. Para las redirecciones temporales, son habituales el 302 o el 307.

2. Ejemplos de implementación del lado del servidor

La implementación exacta depende de la tecnología del lado del servidor que estés utilizando.

a) Node.js (Express.js)

const express = require('express');
const app = express();

// Permanent redirect
app.get('/old-path', (req, res) => {
  res.redirect(301, '/new-path');
});

// Temporary redirect
app.get('/another-old-path', (req, res) => {
  res.redirect('/another-new-path'); // Defaults to 302
});

// Manual redirect with status code
app.get('/manual-redirect', (req, res) => {
  res.writeHead(301, {
    'Location': '/final-destination'
  });
  res.end();
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

b) Python (Flask)

from flask import Flask, redirect, url_for, abort, Response

app = Flask(__name__)

@app.route('/old-path')
def old_path():
    return redirect(url_for('new_path'), code=301)

@app.route('/new-path')
def new_path():
    return "Welcome to the new path!"

@app.route('/another-old-path')
def another_old_path():
    return redirect('/another-new-path') # Defaults to 302

@app.route('/another-new-path')
def another_new_path():
    return "This is another new path!"

@app.route('/manual-redirect')
def manual_redirect():
    response = Response(status=301)
    response.headers['Location'] = '/final-destination'
    return response

@app.route('/final-destination')
def final_destination():
    return "You reached the final destination!"

if __name__ == '__main__':
    app.run(debug=True)

c) PHP

<?php
// Permanent redirect
if ($_SERVER['REQUEST_URI'] === '/old-path') {
    header("HTTP/1.1 301 Moved Permanently");
    header("Location: /new-path");
    exit();
}

// Temporary redirect
if ($_SERVER['REQUEST_URI'] === '/another-old-path') {
    header("Location: /another-new-path"); // Defaults to 302
    exit();
}

// ... rest of your PHP code
?>

d) Apache (.htaccess)

En el caso de los servidores web Apache, las redirecciones suelen configurarse en .htaccess archivos o en la configuración principal del servidor.

# Permanent redirect
Redirect 301 /old-path /new-path

# Permanent redirect for a domain
RedirectMatch 301 ^/old-domain/(.*)$ http://www.new-domain.com/$1

# RewriteRule for more complex redirects
RewriteEngine On
RewriteRule ^old-path-regex$ /new-path-target [R=301,L]

e) Nginx

En los servidores web Nginx, las redirecciones se configuran en el bloque del servidor.

server {
    listen 80;
    server_name example.com;

    # Permanent redirect
    location = /old-path {
        return 301 /new-path;
    }

    # Temporary redirect
    location = /another-old-path {
        return 302 /another-new-path;
    }

    # Redirect entire domain
    server_name old-domain.com;
    return 301 $scheme://new-domain.com$request_uri;

    # ... other configurations
}

3. Consideraciones clave

SEO: Utiliza el código 301 para los cambios permanentes a fin de mantener el posicionamiento en los motores de búsqueda.
Experiencia del usuario: Las redirecciones deben ser rápidas y fluidas. Evita las cadenas de redirecciones (varias redirecciones antes de llegar al destino final), ya que pueden ralentizar la carga de la página.
Seguridad: Ten cuidado al redirigir entradas proporcionadas por el usuario para evitar vulnerabilidades de redireccionamiento abierto. Valida y depura siempre las URL de redireccionamiento.
URL relativas frente a absolutas: puede utilizar rutas relativas para redireccionamientos dentro del mismo dominio (p. ej., /new-path) o URL absolutas para redireccionamientos a dominios diferentes (p. ej., https://www.example.com/new-path).
Registro: Asegúrate de que tu servidor registre las redirecciones, especialmente las 301, para su supervisión y depuración.
Pruebas: Pruebe exhaustivamente toda la lógica de redireccionamiento para asegurarse de que funciona según lo esperado y no crea bucles infinitos ni destinos incorrectos.