En este tutorial, aprenderás a crear tu propia Alternativa a Firebase Dynamic Links con .NET 9 y Firebase, eliminando la dependencia de Firebase Dynamic Links u otros servicios como Bitly o Branch. Este sistema te permitirá generar enlaces personalizados, redirigir tráfico y analizar clics con métricas en Firebase Analytics.

¿Por qué Crear tu Propio Sistema de Dynamic Links?

A partir de agosto de 2025, Firebase Dynamic Links dejará de estar disponible, lo que obliga a las empresas y desarrolladores a buscar alternativas para generar y gestionar enlaces dinámicos. Si actualmente dependes de este servicio, es momento de prepararte para la transición y considerar soluciones autosuficientes o de terceros.

Las principales alternativas comerciales incluyen:

Tecnologías Utilizadas

• Backend Minimal Api: .NET 9
• Base de Datos: Firestore.
• Redirección: Firebase Hosting.
• Métricas y Analítica: Firebase Analytics.

Paso 1: Adquirir y Configurar un Dominio Personalizado

Si deseas que tus enlaces tengan un dominio personalizado en lugar de un subdominio de Firebase, sigue estos pasos:

• Si no dispones de un dominio, puedes comprar uno en DonDominio, Ionos, etc..
• Accede a Firebase Console y dirígete a Hosting, pulsa sobre «Agregar un dominio personalizado»

NOTA: Si ya dispones de un dominio en uso, puedes crear directamente un subdominio para no provocar conflictos.

Pulsa «Continuar» y configura los registros DNS en tu proveedor de dominio, añadiendo los valores CNAME y/o TXT que proporciona Firebase.

Pasados unos minutos, pulsa «Verificar» para completar la configuración. (La verificación puede tardar hasta 24h).

¿Por qué necesitamos configurar el Hosting en Firebase?

Una vez que hemos configurado el dominio personalizado y lo hemos vinculado a Firebase, el siguiente paso es desplegar contenido en el hosting de Firebase. Puede parecer confuso si no hemos creado explícitamente archivos web (como un sitio HTML tradicional), pero Firebase Hosting juega un papel clave en nuestro sistema de enlaces dinámicos.

¿Qué rol cumple Firebase Hosting aquí?

Manejar redirecciones dinámicas:
Con Firebase Hosting puedes crear reglas de redirección (en el archivo firebase.json) para que cualquier solicitud al dominio sea procesada por tus Firebase Functions o una API que decida a dónde redirigir al usuario (por ejemplo, basándose en un enlace almacenado en Firestore).

Punto de entrada para los enlaces cortos:
Cuando alguien hace clic en uno de tus enlaces cortos (por ejemplo, https://enlaces.proximacita.com/abc123), el dominio personalizado necesita saber a dónde dirigir al usuario.
Firebase Hosting actúa como ese punto de entrada y redirige el tráfico a las funciones o APIs configuradas que manejan las redirecciones dinámicas.

Conectar el dominio con Firebase Functions o APIs:
Al desplegar el hosting, establecemos una capa que permite que Firebase maneje las rutas y redirecciones. En este caso, no necesitas un sitio web completo, pero el hosting debe estar activo para que las URLs funcionen correctamente.

¿Qué hace exactamente este comando?

firebase deploy --only hosting

• firebase deploy → Despliega recursos en Firebase.
• --only hosting → Específicamente despliega solo la parte de Hosting (sin afectar Firestore, Functions, etc.).

Este comando:

1. Activa el hosting de tu proyecto en Firebase.
2. Vincula el dominio personalizado (enlaces.proximacita.com) al hosting.
3. Crea una estructura básica (incluso si no tienes un sitio web completo) para que las redirecciones funcionen.

¿Qué necesito antes de ejecutar este comando?

Inicializar Firebase Hosting:
Si no lo has hecho aún, crea y dirígete a una carpeta creada para esto, por ejemplo «project-firebase-links-hosting» y en una terminal ejecuta el comando firebase init hosting. Durante este proceso, elige el proyecto correcto y selecciona un directorio vacío o con un simple index.html. No te preocupes si no tienes contenido aún, solo necesitamos activar el hosting.

Con las flechas del teclado muévete por las opciones y selecciona Use an existing project, encuentra el tuyo y pulsa ENTER para seleccionarlo, luego pulsa continuadamente ENTER para seleccionar las opciones por defecto.

Una vez configurado el hosting, puedes proceder a desplegar con el comando firebase deploy –only hosting en la misma carpeta.

Aunque parezca que no hay «nada que desplegar», este paso es esencial para que Firebase Hosting actúe como intermediario entre el dominio personalizado y tu lógica de redirección. Sin este despliegue, el dominio no sabrá cómo manejar las URLs que reciba.

¿Qué pasará después de desplegar?

• Obtendrás un mensaje de éxito con la URL de tu hosting, por ejemplo Hosting URL: https://enlaces.proximacita.com
• Ahora, cualquier enlace corto que genere tu sistema funcionará correctamente, redirigiendo a los usuarios a sus destinos correspondientes.

Paso 2: Configurar Firestore para Almacenar los Enlaces

Usaremos Firestore para almacenar los enlaces. Puedes crearlo en Firebase Console:

Después de pulsar «Crear base de datos» y seleccionar la región para tu base de datos, se te pedirá que elijas las reglas de seguridad iniciales. Para facilitar el proceso de configuración durante el desarrollo, selecciona la opción:

Comenzar en modo de prueba

Esta opción te permitirá acceder y modificar los datos sin restricciones mientras desarrollas tu aplicación. Es ideal para realizar pruebas sin preocuparte por configuraciones avanzadas de seguridad en esta etapa.

⚠️ Importante:
El modo de prueba abre el acceso de lectura y escritura a cualquier usuario durante 30 días. Después de ese período, las reglas se bloquearán automáticamente si no se actualizan. Por motivos de seguridad, no debes usar este modo en entornos de producción.

¿Qué significa el modo de prueba?

No es seguro para aplicaciones públicas o en producción.

Permite leer y escribir en la base de datos sin autenticación.

Ideal para desarrollo y pruebas iniciales.

Más adelante en el tutorial, aprenderemos a configurar reglas de seguridad personalizadas para proteger tu base de datos en un entorno productivo. Esto incluirá restricciones de acceso basadas en autenticación, roles de usuario y otras políticas de seguridad.

Paso 3: Crear la API en .NET 9

En Visual Studio o desde la terminal, crea un nuevo proyecto:

dotnet new webapi -n DynamicLinksAPI
cd DynamicLinksAPI

Instala el SDK de Firebase para .NET:

dotnet add package FirebaseAdmin
dotnet add package Google.Cloud.Firestore

Reemplaza el contenido de Program.cs con el siguiente código:

using FirebaseAdmin;
using Google.Apis.Auth.OAuth2;
using Google.Cloud.Firestore;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

IConfiguration configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json") // Carga el archivo appsettings.json predeterminado
    .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json",
        true)
    .Build();

Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", configuration["FirebaseJson"]);

FirebaseApp.Create(new AppOptions
{
    Credential = GoogleCredential.FromFile(configuration["FirebaseJson"])
});


builder.Services.AddOpenApi();

// Configuración de Firestore
builder.Services.AddSingleton(FirestoreDb.Create("proximacita-com"));

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
}

app.UseHttpsRedirection();

app.MapPost("/api/shortlinks/create", async ([FromBody] CreateLinkRequest request, FirestoreDb firestoreDb) =>
{
    if (string.IsNullOrEmpty(request.DestinationUrl))
        return Results.BadRequest("La URL de destino es requerida.");

    string shortId = Guid.NewGuid().ToString("N").Substring(0, 6);
    var docRef = firestoreDb.Collection("ShortLinks").Document(shortId);

    var data = new Dictionary<string, object>
    {
        { "Destination", request.DestinationUrl },
        { "Clicks", 0 },
        { "CreatedAt", Timestamp.GetCurrentTimestamp() },
        { "Expiration", request.Expiration.HasValue ? Timestamp.FromDateTime(request.Expiration.Value) : null }
    };

    await docRef.SetAsync(data);
    return Results.Ok(new { shortUrl = $"https://enlaces.proximacita.com/{shortId}" });
});

app.MapGet("/api/shortlinks/{shortId}", async (string shortId, FirestoreDb firestoreDb) =>
{
    var docRef = firestoreDb.Collection("ShortLinks").Document(shortId);
    var snapshot = await docRef.GetSnapshotAsync();

    if (!snapshot.Exists)
        return Results.NotFound("URL no encontrada");

    var data = snapshot.ToDictionary();
    if (!Uri.IsWellFormedUriString(data["Destination"].ToString(), UriKind.Absolute))
        return Results.BadRequest("La URL de destino no es válida.");

    await docRef.UpdateAsync("Clicks", (long)data["Clicks"] + 1);
    return Results.Redirect(data["Destination"].ToString());
});

app.Run();

record CreateLinkRequest(string DestinationUrl, DateTime? Expiration);

Configurando las Credenciales de Firebase en appsettings.json

Para conectar tu aplicación con Firebase de forma segura, es necesario utilizar un archivo de credenciales JSON que proporciona Firebase. Este archivo contiene las claves y configuraciones necesarias para autenticar tu aplicación con los servicios de Google Cloud.

Exportar el archivo JSON de credenciales desde Firebase:

1. Ve a la Consola de Firebase.
2. Selecciona tu proyecto.
3. En el menú lateral, haz clic en Configuración del proyecto.
4. Ve a la pestaña «Cuentas de servicio».
5. Haz clic en «Generar nueva clave privada».
6. Esto descargará un archivo firebase-adminsdk-XXXXX.json. Guárdalo en un lugar seguro.

Agregar el archivo a tu proyecto de .NET:

• Coloca el archivo JSON en una carpeta segura dentro de tu proyecto. Una convención común es usar una carpeta llamada Secrets.
• Ejemplo de estructura del proyecto:

/DynamicLinksAPI
├── /Secrets
│   └── firebase-secret.json
├── Program.cs
├── appsettings.json
└── ...

NOTA: Asegúrate de que la carpeta Secrets esté incluida en el archivo .gitignore para evitar que las credenciales se suban al repositorio.

Configurar la ruta en appsettings.json:

En tu appsettings.json, añade una entrada que apunte a la ubicación del archivo JSON de credenciales:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "FirebaseJson": "./Secrets/firebase-adminsdk-XXXXX.json"
}

Despliegue API y reconfiguración de Hosting

Si has probado la API en local, verás que se generan correctamente los enlaces, por ejemplo:

Si visitas el enlaces te toparás con el mensaje de Firebase, lo que significa que la configuración ha sido correcta, pero que no encuentra a qué endpoint de nuestra API debe redireccionar la url.

Para solucionar esto, tenemos que editar el archivo firebase.json de nuestro mini proyecto de hosting y reemplazarlo por el siguiente:

{
  "hosting": {
    "public": "public",
    "redirects": [
      {
        "source": "/:shortId",
        "destination": "https://dynamiclinksapi20250219225215.azurewebsites.net/api/shortlinks/:shortId",
        "type": 302
      }
    ],
    "cleanUrls": true,
    "trailingSlash": false
  }
}

Como puedes ver, hay una regla en el código:

/{shortId} → Endpoint de redirección:

• Cuando alguien acceda a un enlace corto como https://enlaces.proximacita.com/abc123, se redirigirá al endpoint correspondiente de tu API que maneja la redirección:
  • https://dynamiclinksapi20250219225215.azurewebsites.net/api/shortlinks/abc123

Como has podido observar, es necesario que despliegues tu API, ya sea Azure o el proveedor que desees, para vincular los enlaces públicos en las reglas de redirección.

Una vez modificado el archivo firebase.json, hay que volver a ejecutar el comando firebase deploy –only hosting

Ya puedes probar la creación de enlaces:

curl --location 'https://dynamiclinksapi20250219225215.azurewebsites.net/api/shortlinks/create' \
--header 'Content-Type: application/json' \
--header 'Cookie: ARRAffinity=79e06db539acb57119e709978d2cf1da299e8341753d6f6345007fcab3f69bc5; ARRAffinitySameSite=79e06db539acb57119e709978d2cf1da299e8341753d6f6345007fcab3f69bc5' \
--data '{
  "destinationUrl": "https://www.davidcanton.net",
  "expiration": "2025-12-31T23:59:59Z"
}'

{
    "shortUrl": "https://enlaces.proximacita.com/6d8c91"
}

Y cuando visites https://enlaces.proximacita.com/6d8c91:

¡VOILÁ!

Además, si observas la colección de Firestore, verás que estamos registrando correctamente los clicks:

Link al código completo en GitHub: https://github.com/davidcantonnadales/DynamicLinksAPI

Ejemplo de Reglas de Seguridad para Producción en Firestore

Cuando tu aplicación esté lista para producción, es fundamental restringir el acceso a la base de datos para proteger los datos de tus usuarios. A continuación te muestro un ejemplo básico de configuración segura:

Solo usuarios autenticados pueden leer y escribir:

rules_version = '2';

service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      // Permitir acceso solo a usuarios autenticados
      allow read, write: if request.auth != null;
    }
  }
}

¿Qué hace esta regla?

Usuarios no autenticados recibirán un error PERMISSION_DENIED.

(Opcional) Configuración de Firebase Analytics

Si aún no has conectado tu aplicación o sitio web a Firebase Analytics, sigue estos pasos:

Habilitar Firebase Analytics:

1. Abre tu proyecto en Firebase Console.
2. Ve a Analytics → Dashboard.
3. Si no has habilitado Analytics, sigue las instrucciones para vincular tu proyecto a Google Analytics.

Configurar Eventos Personalizados desde la API

Ya que las redirecciones pasan por tu API de Azure, puedes enviar eventos personalizados a Firebase Analytics desde el backend.

Ejemplo en C# (.NET) usando Google Analytics Measurement Protocol:

1. Instala HttpClient en tu proyecto si no lo has hecho.
2. Agrega el siguiente código a tu API en Azure para enviar eventos a Google Analytics cuando se use un enlace corto:

using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

public async Task TrackLinkClick(string shortId, string destinationUrl)
{
    var measurementId = "G-XXXXXXXXXX"; // Tu Measurement ID de Google Analytics
    var apiSecret = "YOUR_API_SECRET";  // API Secret de Measurement Protocol

    var httpClient = new HttpClient();

    var payload = new
    {
        client_id = Guid.NewGuid().ToString(),
        events = new[]
        {
            new
            {
                name = "link_click",
                params = new
                {
                    short_id = shortId,
                    destination_url = destinationUrl
                }
            }
        }
    };

    var response = await httpClient.PostAsync(
        $"https://www.google-analytics.com/mp/collect?measurement_id={measurementId}&api_secret={apiSecret}",
        new StringContent(JsonSerializer.Serialize(payload))
    );

    if (!response.IsSuccessStatusCode)
    {
        // Manejar errores si es necesario
        Console.WriteLine("Error enviando evento a Google Analytics");
    }
}

• measurementId: Lo obtienes desde Firebase Console → Analytics → Configuración.
• apiSecret: Lo generas desde Google Analytics → Admin → Data Streams → Measurement Protocol API.

Llama a este método justo después de que un enlace corto redirija al usuario.

Ver Datos en Firebase Analytics

Una vez configurado y enviando eventos:

1. Ve a Firebase Console → Analytics → Events.
2. Deberías ver el evento personalizado link_click.
3. Puedes desglosar por parámetros como:
   • short_id: El identificador del enlace corto.
   • destination_url: El destino final del enlace.

Ver detalles adicionales:

• Usuarios que hacen clic.
• Ubicación geográfica.
• Dispositivo y plataforma.

Integración con Google Looker Studio

Si quieres crear reportes más personalizados:

1. Abre Google Looker Studio.
2. Crea un nuevo reporte.
3. Conecta Firebase Analytics como fuente de datos.
4. Configura un dashboard que muestre:
   • Total de clics por enlace corto.
   • Enlaces más populares.
   • Clics por ubicación geográfica.
   • Tasa de conversión (si corresponde).

Visualización en Tiempo Real

En Firebase Analytics → Dashboard también puedes ver:

• Usuarios activos.
• Clics en enlaces en tiempo real.
• Flujo de usuarios desde el enlace corto hasta el destino final.

Conclusión

¡Felicidades! Has construido con éxito tu propia Alternativa a Firebase Dynamic Links utilizando .NET 9, Firebase Hosting, y Firestore. Este proyecto te permite tener un control total sobre la creación y gestión de enlaces dinámicos, eliminando la dependencia de servicios externos como Firebase Dynamic Links, Bitly, o Branch.

Con esta solución ahora puedes:

✅ Crear enlaces dinámicos personalizados:
Genera enlaces únicos y personalizados para cualquier propósito, ya sea para campañas de marketing, invitaciones o seguimiento de usuarios.

✅ Redirigir usuarios a destinos específicos:
Dirige a los usuarios automáticamente a diferentes páginas web o rutas según el enlace utilizado, facilitando el flujo y la experiencia del usuario.

✅ Registrar clics y generar reportes:
Cada vez que alguien haga clic en uno de tus enlaces cortos, podrás registrar esa interacción y visualizarla en Firebase Analytics o en dashboards personalizados usando Google Looker Studio.

✅ Escalabilidad y control total:
Alojado en Azure y servido desde Firebase Hosting, tu sistema es escalable y completamente bajo tu control, con la flexibilidad de modificar la lógica o integrarlo con otros sistemas.

✅ Seguridad:
Gracias a la integración con Firebase Authentication (si decides añadirla), puedes limitar la creación y gestión de enlaces solo a usuarios autenticados, asegurando que solo personas autorizadas puedan generar y analizar los enlaces.

🚀 ¿Qué sigue?

Este es solo el comienzo. Aquí tienes algunas ideas para seguir expandiendo este proyecto:

• Agrega soporte para analíticas avanzadas:
  Integra eventos personalizados más detallados para obtener métricas como ubicación, dispositivo o fuente de tráfico.
• Personalización de URLs:
  Permite que los usuarios puedan elegir parte del identificador del enlace corto para hacerlo más memorable o amigable.
• Interfaz de usuario (UI):
  Crea un sencillo panel de administración donde los usuarios puedan generar enlaces cortos, ver estadísticas y gestionar sus enlaces existentes.
• Seguridad y cuotas:
  Implementa límites de creación de enlaces por usuario y protecciones contra abusos.

💬 ¿Tienes dudas, sugerencias o quieres más detalles?
Déjamelo en los comentarios o visita mi blog 👉 www.davidcanton.net para más tutoriales, guías y proyectos como este.

¡Gracias por seguir el tutorial para montar tu propia Alternativa a Firebase Dynamic Links y nos vemos en el próximo proyecto! 🚀🔥