Sottodomini dinamici in asp.net mvc

Question

Sono abbastanza nuovo su asp.net e ho poca esperienza con iis. Vorrei che ogni utente della mia applicazione ottenga il proprio sottodominio, ma tutti usano gli stessi controller. Il sottodominio controlla quindi quale contenuto viene visualizzato.

Esempio:

user1subdomain.mydomain.com/Whatever
user2subdomain.mydomain.com/Whatever

Utilizzeranno entrambi lo stesso controller. Idealmente, un parametro potrebbe fornire il nome utente al controller, che potrebbe quindi visualizzare il contenuto appropriato. Vorrei che fosse abbastanza flessibile da poter aggiungere nuovi sottodomini al database senza riscrivere le regole di routing ogni volta che viene aggiunto un nuovo sottodominio.

Answer 1

MVC non è associato al dominio, ma solo al percorso (ad es. http: // dominio / percorso ).

Per farlo correttamente è necessario quanto segue ...

1. Configurazione DNS con caratteri jolly per * .yourdomain.com che punta al tuo server.
2. Il sito nella configurazione di IIS con nessuna intestazione host. Qualsiasi altro sito ospitato in quell'istanza di IIS su lo stesso IP deve avere intestazioni Host specificato.
3. La tua applicazione dovrà controllare il richiesta intestazione host al caricamento della pagina, inizio sessione o qualche altro evento.

Answer 2

Ho trovato una risposta più semplice sul blog di questa persona. Molto sorpreso che funzioni così come è e che questa soluzione ha più di 4 anni.

http: //blog.maartenballiauw. essere / post / 2009/05/20 / aspnet-MVC-domain-routing.aspx

Un'implementazione del percorso personalizzata:

public class DomainRoute : Route
{
    public string Domain { get; set; }


    public override RouteData GetRouteData(HttpContextBase httpContext)
    {
        // Build regex
        domainRegex = CreateRegex(Domain);
        pathRegex = CreateRegex(Url);

        // Request information
        string requestDomain = httpContext.Request.Headers["host"];
        if (!string.IsNullOrEmpty(requestDomain))
        {
            if (requestDomain.IndexOf(":") > 0)
            {
                requestDomain = requestDomain.Substring(0, requestDomain.IndexOf(":"));
            }
        }
        else
        {
            requestDomain = httpContext.Request.Url.Host;
        }
        string requestPath = httpContext.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + httpContext.Request.PathInfo;

        // Match domain and route
        Match domainMatch = domainRegex.Match(requestDomain);
        Match pathMatch = pathRegex.Match(requestPath);

        // Route data
        RouteData data = null;
        if (domainMatch.Success && pathMatch.Success)
        {
            data = new RouteData(this, RouteHandler);

            // Add defaults first
            if (Defaults != null)
            {
                foreach (KeyValuePair<string, object> item in Defaults)
                {
                    data.Values[item.Key] = item.Value;
                }
            }

            // Iterate matching domain groups
            for (int i = 1; i < domainMatch.Groups.Count; i++)
            {
                Group group = domainMatch.Groups[i];
                if (group.Success)
                {
                    string key = domainRegex.GroupNameFromNumber(i);
                    if (!string.IsNullOrEmpty(key) && !char.IsNumber(key, 0))
                    {
                        if (!string.IsNullOrEmpty(group.Value))
                        {
                            data.Values[key] = group.Value;
                        }
                    }
                }
            }

            // Iterate matching path groups
            for (int i = 1; i < pathMatch.Groups.Count; i++)
            {
                Group group = pathMatch.Groups[i];
                if (group.Success)
                {
                    string key = pathRegex.GroupNameFromNumber(i);
                    if (!string.IsNullOrEmpty(key) && !char.IsNumber(key, 0))
                    {
                        if (!string.IsNullOrEmpty(group.Value))
                        {
                            data.Values[key] = group.Value;
                        }
                    }
                }
            }
        }    
    return data;
    }

    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
        return base.GetVirtualPath(requestContext, RemoveDomainTokens(values));
    }

    public DomainData GetDomainData(RequestContext requestContext, RouteValueDictionary values)
    {
        // Build hostname
        string hostname = Domain;
        foreach (KeyValuePair<string, object> pair in values)
        {
            hostname = hostname.Replace("{" + pair.Key + "}", pair.Value.ToString());
        }

        // Return domain data
        return new DomainData
        {
            Protocol = "http",
            HostName = hostname,
            Fragment = ""
        };
    }}

Ed ecco come può essere utilizzato.

routes.Add("DomainRoute", new DomainRoute(
"{controller}-{action}.example.com",     // Domain with parameters
"{id}",    // URL with parameters
new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
));

Answer 3

Principalmente non è un problema. Penso!

In termini di applicazione / routing, il routing inizia dove finisce il dominio, quindi mappare più domini sulla stessa applicazione non è un problema, funzionerà semplicemente.

In termini di IIS puoi mappare tutti i domini che vuoi (beh, ci sarà sicuramente un limite) su un singolo sito - non sono sicuro che tu possa usare un carattere jolly - quale versione di IIS stai usando?

Quando arriva una richiesta ci sono eventi che puoi agganciare per guardare il dominio e quindi impostare i parametri che desideri (utente per esempio), l'URL radice per la richiesta è disponibile anche dal contesto più avanti nel ciclo - ma tu voglio prenderlo presto.

Se riesci a fare i caratteri jolly diventa abbastanza banale: raccogli la richiesta, convalida il sottodominio rispetto agli utenti nel database (se non reindirizzamento valido al sito predefinito), imposta l'utente e prosegui attraverso il normale routing.

Se non è possibile eseguire caratteri jolly, la sfida consiste nell'aggiungere le intestazioni host all'applicazione IIS (sito Web) al volo dall'applicazione man mano che gli utenti vengono aggiunti al database.