SqlMembershipProvider IIS와 SQL은 다른 컴퓨터에 있습니까?

Question

우리는 내 웹 사이트 중 하나를 프로덕션으로 이동하고 있습니다. 방화벽과 웹 사이트 및 데이터베이스가 서로 다른 컴퓨터에 있기 때문에 웹 사이트를 SQL 서버에 직접 연결할 수 없습니다. 우리는 WCF 서비스를 통해 모든 데이터베이스 액세스를 실행하도록 설정했습니다. 이 모든 것은 잘 작동합니다.

그러나 문제는 AspNetSqlProvider에 거짓말을 발견했습니다. 사이트에 설정하는 것 외에 다른 공급자에 익숙하지 않지만 수집 한 항목에서 공급자 개체에 연결 문자열을 전달하고 웹 사이트의 ASP.NET 계정을 자동으로 처리합니다. 그러나 제작 과정에서이 작업을 수행 할 수는 없지만 웹 사이트와 데이터베이스를 서로 볼 수 없으며 IIS와 데이터베이스의 자동 연결이 작동하지 않습니다.

주제가 this으로 판단 되나, 원래의 개념/문제는 아닙니다. 나는 며칠 동안 그것을 연구했지만 아무 도움이되지 않았다. 필자는 새로운 상속 된 MembershipProvider 클래스를 만들고 모든 메서드를 재정의하는 방법을 설명한 하나 또는 두 개의 기사를 찾았습니다. 하지만 이것은 엄청난 노동이며, 나는 공통적 인 것으로 생각되는 문제에 대한 해결책을 볼 수 없다.

IIS와 데이터베이스가 서로 다른 컴퓨터에있을 때 어떻게 AspNetSqlProvider를 설정할 수 있습니까? wcf 서비스 또는 다른 객체를 통해 AspNetSqlProvider를 실행하여 SQL 서버에 직접 연결하지 못하도록하는 방법이 있습니까?

미리 감사드립니다.

Answer 1

이 서비스와 관련하여 맞춤 멤버 자격 공급자를 래핑 할 수 있습니다. 마음 속에 잘 보관해야 할 것은 끝점을 확보하는 것입니다! 끝내기!

인증서 또는 AD 또는 무엇이든 및을 사용하여 사용자 자격 증명을 전달할 수 있습니다.

이 클래스의 모든 메소드를 테스트하지는 않았지만 이전 구현은 정상적으로 수행되었으므로 결과가 나오는 곳으로 이동할 수 있습니다.

안전한 엔드 포인트!

// <copyright project="Salient.ScriptModel" file="MembershipService.svc" company="Sky Sanders"> 
// http://skysanders.net/subtext 
// Attribution is appreciated 
// </copyright> 
// <version>1.0</version> 
using System; 
using System.Collections.Generic; 
using System.Runtime.Serialization; 
using System.ServiceModel; 
using System.ServiceModel.Activation; 
using System.Web.Security; 

namespace Salient.ScriptModel 
{ 
    [ServiceContract(Namespace = "Salient.ScriptModel", Name = "MembershipProvider")] 
    public interface IMembershipProvider 
    { 
     string ProviderName { get; set; } 

     [OperationContract] 
     DateTime TestInput(DateTime date); 

     [OperationContract] 
     ProviderProperties GetProviderProperties(); 

     [OperationContract] 
     MembershipUser GetUserByKey(object providerUserKey, bool userIsOnline); 

     [OperationContract] 
     MembershipCreateResult CreateUser(string username, string password, 
              string email, string passwordQuestion, 
              string passwordAnswer, bool isApproved, 
              object providerUserKey); 

     [OperationContract] 
     MembershipCreateResult AddUser(MembershipUser user); 

     [OperationContract] 
     bool ChangePasswordQuestionAndAnswer(string username, string password, 
              string newPasswordQuestion, string newPasswordAnswer); 

     [OperationContract] 
     string GetPassword(string username, string answer); 

     [OperationContract] 
     bool ChangePassword(string username, string oldPassword, string newPassword); 

     [OperationContract] 
     string ResetPassword(string username, string answer); 

     [OperationContract] 
     void UpdateUser(MembershipUser user); 

     [OperationContract] 
     bool ValidateUser(string username, string password); 

     [OperationContract] 
     bool UnlockUser(string userName); 

     [OperationContract] 
     MembershipUser GetUserByName(string username, bool userIsOnline); 

     [OperationContract] 
     string GetUserNameByEmail(string email); 

     [OperationContract] 
     bool DeleteUser(string username, bool deleteAllRelatedData); 

     [OperationContract] 
     MembershipFindResult GetAllUsers(int pageIndex, int pageSize); 

     [OperationContract] 
     int GetNumberOfUsersOnline(); 

     [OperationContract] 
     MembershipFindResult FindUsersByName(string usernameToMatch, int pageIndex, 
              int pageSize); 

     [OperationContract] 
     MembershipFindResult FindUsersByEmail(string emailToMatch, int pageIndex, 
               int pageSize); 
    } 

    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)] 
    public class MembershipProvider : IMembershipProvider 
    { 
     private System.Web.Security.MembershipProvider Provider 
     { 
      get 
      { 
       if (string.IsNullOrEmpty(ProviderName)) 
       { 
        return Membership.Provider; 
       } 
       return Membership.Providers[ProviderName]; 
      } 
     } 

     #region IMembershipProvider Members 

     public DateTime TestInput(DateTime date) 
     { 
      return date; 
     } 

     public string ProviderName { get; set; } 

     public ProviderProperties GetProviderProperties() 
     { 
      var returnValue = new ProviderProperties 
            { 
             ApplicationName = Provider.ApplicationName, 
             EnablePasswordReset = Provider.EnablePasswordReset, 
             EnablePasswordRetrieval = Provider.EnablePasswordRetrieval, 
             MaxInvalidPasswordAttempts = Provider.MaxInvalidPasswordAttempts, 
             MinRequiredNonAlphanumericCharacters = 
              Provider.MinRequiredNonAlphanumericCharacters, 
             MinRequiredPasswordLength = Provider.MinRequiredPasswordLength, 
             PasswordAttemptWindow = Provider.PasswordAttemptWindow, 
             PasswordFormat = Provider.PasswordFormat, 
             PasswordStrengthRegularExpression = Provider.PasswordStrengthRegularExpression, 
             RequiresQuestionAndAnswer = Provider.RequiresQuestionAndAnswer, 
             RequiresUniqueEmail = Provider.RequiresUniqueEmail 
            }; 
      return returnValue; 
     } 

     public MembershipUser GetUserByKey(object providerUserKey, bool userIsOnline) 
     { 
      return Provider.GetUser(providerUserKey, userIsOnline); 
     } 

     public MembershipCreateResult CreateUser(string username, string password, 
               string email, string passwordQuestion, 
               string passwordAnswer, bool isApproved, 
               object providerUserKey) 
     { 
      MembershipCreateStatus status; 
      MembershipUser user = Provider.CreateUser(username, password, email, passwordQuestion, passwordAnswer, 
                 isApproved, 
                 providerUserKey, out status); 
      return new MembershipCreateResult(user, status); 
     } 

     public MembershipCreateResult AddUser(MembershipUser user) 
     { 
      return new MembershipCreateResult(user, MembershipCreateStatus.DuplicateEmail); 
     } 

     public bool ChangePasswordQuestionAndAnswer(string username, string password, 
                string newPasswordQuestion, string newPasswordAnswer) 
     { 
      return Provider.ChangePasswordQuestionAndAnswer(username, password, newPasswordQuestion, newPasswordAnswer); 
     } 

     public string GetPassword(string username, string answer) 
     { 
      return Provider.GetPassword(username, answer); 
     } 

     public bool ChangePassword(string username, string oldPassword, string newPassword) 
     { 
      return Provider.ChangePassword(username, oldPassword, newPassword); 
     } 

     public string ResetPassword(string username, string answer) 
     { 
      return Provider.ResetPassword(username, answer); 
     } 

     public void UpdateUser(MembershipUser user) 
     { 
      Provider.UpdateUser(user); 
     } 

     public bool ValidateUser(string username, string password) 
     { 
      return Provider.ValidateUser(username, password); 
     } 

     public bool UnlockUser(string userName) 
     { 
      return Provider.UnlockUser(userName); 
     } 

     public MembershipUser GetUserByName(string username, bool userIsOnline) 
     { 
      return Provider.GetUser(username, userIsOnline); 
     } 

     public string GetUserNameByEmail(string email) 
     { 
      return Provider.GetUserNameByEmail(email); 
     } 

     public bool DeleteUser(string username, bool deleteAllRelatedData) 
     { 
      return Provider.DeleteUser(username, deleteAllRelatedData); 
     } 

     public MembershipFindResult GetAllUsers(int pageIndex, int pageSize) 
     { 
      int totalRecords; 
      MembershipUserCollection users = Provider.GetAllUsers(pageIndex, pageSize, out totalRecords); 
      var list = new List<MembershipUser>(); 
      foreach (MembershipUser user in users) 
      { 
       list.Add(user); 
      } 
      return new MembershipFindResult(list, totalRecords); 
     } 

     public int GetNumberOfUsersOnline() 
     { 
      return Provider.GetNumberOfUsersOnline(); 
     } 

     public MembershipFindResult FindUsersByName(string usernameToMatch, int pageIndex, 
                int pageSize) 
     { 
      int totalRecords; 
      MembershipUserCollection users = Provider.FindUsersByName(usernameToMatch, pageIndex, pageSize, 
                     out totalRecords); 
      var list = new List<MembershipUser>(); 
      foreach (MembershipUser user in users) 
      { 
       list.Add(user); 
      } 
      return new MembershipFindResult(list, totalRecords); 
     } 

     public MembershipFindResult FindUsersByEmail(string emailToMatch, int pageIndex, 
                int pageSize) 
     { 
      int totalRecords; 
      MembershipUserCollection users = Provider.FindUsersByEmail(emailToMatch, pageIndex, pageSize, 
                     out totalRecords); 
      var list = new List<MembershipUser>(); 
      foreach (MembershipUser user in users) 
      { 
       list.Add(user); 
      } 
      return new MembershipFindResult(list, totalRecords); 
     } 

     #endregion 
    } 

    [DataContract] 
    public class MembershipFindResult 
    { 
     [DataMember] public int RecordCount; 
     [DataMember] public IEnumerable<MembershipUser> Users; 

     public MembershipFindResult() 
     { 
     } 

     public MembershipFindResult(IEnumerable<MembershipUser> users, int recordCount) 
     { 
      Users = users; 
      RecordCount = recordCount; 
     } 
    } 

    [DataContract] 
    public class MembershipCreateResult 
    { 
     [DataMember] public MembershipCreateStatus CreateStatus; 
     [DataMember] public MembershipUser User; 

     public MembershipCreateResult() 
     { 
     } 

     public MembershipCreateResult(MembershipUser user, MembershipCreateStatus createStatus) 
     { 
      User = user; 
      CreateStatus = createStatus; 
     } 
    } 

    [DataContract] 
    public class ProviderProperties 
    { 
     public ProviderProperties() 
     { 
     } 

     public ProviderProperties(bool enablePasswordRetrieval, bool enablePasswordReset, bool requiresQuestionAndAnswer, 
            int maxInvalidPasswordAttempts, 
            int passwordAttemptWindow, bool requiresUniqueEmail, 
            MembershipPasswordFormat passwordFormat, int minRequiredPasswordLength, 
            int minRequiredNonAlphanumericCharacters, 
            string passwordStrengthRegularExpression, string applicationName) 
     { 
      EnablePasswordRetrieval = enablePasswordRetrieval; 
      EnablePasswordReset = enablePasswordReset; 
      RequiresQuestionAndAnswer = requiresQuestionAndAnswer; 
      MaxInvalidPasswordAttempts = maxInvalidPasswordAttempts; 
      PasswordAttemptWindow = passwordAttemptWindow; 
      RequiresUniqueEmail = requiresUniqueEmail; 
      PasswordFormat = passwordFormat; 
      MinRequiredPasswordLength = minRequiredPasswordLength; 
      MinRequiredNonAlphanumericCharacters = minRequiredNonAlphanumericCharacters; 
      PasswordStrengthRegularExpression = passwordStrengthRegularExpression; 
      ApplicationName = applicationName; 
     } 

     [DataMember] 
     public bool EnablePasswordRetrieval { get; set; } 

     [DataMember] 
     public bool EnablePasswordReset { get; set; } 

     [DataMember] 
     public bool RequiresQuestionAndAnswer { get; set; } 

     [DataMember] 
     public int MaxInvalidPasswordAttempts { get; set; } 

     [DataMember] 
     public int PasswordAttemptWindow { get; set; } 

     [DataMember] 
     public bool RequiresUniqueEmail { get; set; } 

     [DataMember] 
     public MembershipPasswordFormat PasswordFormat { get; set; } 

     [DataMember] 
     public int MinRequiredPasswordLength { get; set; } 

     [DataMember] 
     public int MinRequiredNonAlphanumericCharacters { get; set; } 

     [DataMember] 
     public string PasswordStrengthRegularExpression { get; set; } 

     [DataMember] 
     public string ApplicationName { get; set; } 
    } 

} 

편집 : 맞는 댓글을 삭제해야했습니다.

p.s. 이 끝 부분을 확인하십시오!