Sous-domaines dynamiques dans asp.net mvc

Question

Je suis assez nouveau sur asp.net et n’ai que peu d’expérience avec IIS. J'aimerais que chaque utilisateur de mon application obtienne son propre sous-domaine, mais tous utilisent les mêmes contrôleurs. Le sous-domaine contrôlerait alors le contenu affiché.

Exemple:

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

Utilisera-t-il le même contrôleur? Idéalement, un paramètre pourrait donner le nom d'utilisateur au contrôleur, qui pourrait alors afficher le contenu approprié. Je voudrais qu'il soit suffisamment souple pour que de nouveaux sous-domaines puissent être ajoutés à la base de données sans réécrire les règles de routage chaque fois qu'un nouveau sous-domaine est ajouté.

Answer 1

MVC n'est pas lié au domaine, mais uniquement au chemin d'accès (par exemple, http: // domaine / chemin ).

Pour le faire correctement, vous avez besoin des éléments suivants ...

1. Configuration Wildcard DNS pour * .votredomaine.com pointant sur votre serveur.
2. Le site dans la configuration d'IIS avec pas d'en-tête d'hôte. Tout autre site hébergé dans cette instance d'IIS sur la même adresse IP doit avoir des en-têtes d'hôte spécifié.
3. Votre application devra vérifier la demande en-tête d'hôte soit au chargement de la page, début de session ou autre événement.

Answer 2

J'ai trouvé une réponse plus facile sur le blog de cette personne. Très surpris, cela fonctionne aussi bien et que cette solution a plus de 4 ans.

http: //blog.maartenballiauw. be / post / 2009/05/20 / aspnet-mvc-domain-routing.aspx

Une implémentation de route personnalisée:

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 = ""
        };
    }}

Et voici comment il peut être utilisé.

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

Généralement pas un problème. Je pense!

En termes d’application / de routage, le routage commence à l’endroit où le domaine se termine, ainsi la correspondance de plusieurs domaines avec la même application n’est pas un problème, cela fonctionnera tout simplement.

En ce qui concerne IIS, vous pouvez mapper autant de domaines que vous le souhaitez (il doit y avoir une limite) vers un seul site. Je ne sais pas si vous pouvez utiliser un caractère générique. Quelle version d’IIS utilisez-vous?

Lorsqu’une requête arrive, vous pouvez vous connecter à des événements pour consulter le domaine et donc définir les paramètres souhaités (utilisateur par exemple). L’URL racine de la requête est également disponible à partir du contexte plus tard dans le cycle. 'voudrez le ramasser tôt.

Si vous pouvez créer des caractères génériques, cela devient assez trivial - prenez la demande, validez le sous-domaine par rapport aux utilisateurs de la base de données (si la redirection non valide vers le site par défaut), définissez l'utilisateur et poursuivez le routage normal.

Si vous ne pouvez pas créer de joker, le défi consiste à ajouter des en-têtes d’hôte à l’application IIS (site Web) à la volée depuis votre application, à mesure que les utilisateurs sont ajoutés à la base de données.