Azure云服务中的进程通信和数据预加载


http://blogs.msdn.com/b/jianwu/archive/2014/09/11/azure-paas.aspx(Azure PaaS - Cloud Service服务架构及快速调试)中,大家了解到了云服务(Cloud Service)在实际运行过程中的具体分布:多个进程依次被启动。其中,最为重要的是进程WaIISHost(WaWorkerHost)和w3wp进程,前者运行着WebRole.cs(WorkerRole.cs)中代码逻辑及维持着Microsoft.WindowsAzure.ServiceRuntime环境,后者运行着网站(服务)项目的业务逻辑。如图所示:

由于在开发时,WebRole.cs(WorkerRole.cs)和网站项目所属于同一个项目且定义在同一个命名空间(NameSpace)下面,在一些开发项目中,常常会遇到一个问题:

1. 如何让WebRole.cs(WorkerRole.cs)和网站项目快速的共享信息(即部署到云中后,WaIISHost(WaWorkerHost)和w3wp进程高效通信)

2. 如何使得网站项目w3wp能在刚启动时就先加载一些依赖数据(如供查询用的词典库)

本篇就这两个问题,结合手头上跟进的一两个项目,对常用的方法加以总结。主要覆盖以下几个方面:

1. 使用WCF服务来交换信息(进程通信)

2. 使用公有云缓存来共享信息(数据预加载)

3. 云中常用的数据交互方式

 

(一)使用WCF服务来交换信息

一个常见的场景是:WebRole.cs中的代码逻辑需要读取网站配置中的配置项(如变量字符串,数据库连接等),且网站配置中的内容有可能是来自于web.config,也有可能来自Web Config Transformation以后的结果。

关于Web Config Transformation,这里简单描述一下:

添加配置项到web.config时,既可以直接添加配置节 如<appSettings> <add key="setting1" value="hello, world."/> </appSettings>到web.config中,也可以通过项目属性中的setting来添加,如图:

添加完成以后,可以发现,两种不同方式添加进来的配置出现在不同的配置节里。<applicationSettings>中指明了配置变量的类型和使用空间范围,较<appSettings>更适用于较大的项目。

对于<appSettings>下的配置,可以采用System.Configuration.ConfigurationManager.AppSettings["setting1"].ToString();方法来读取。

对于<applicationSettings>下的配置,可以采用Properties.Settings.Default["Setting1"].ToString();方法来读取。

 

实际项目过程中,本地调试和线上运行时所依赖的配置项很可能不相同,仔细查看VS项目会发现,web.config下面有子文件,如web.debug.config,开发者可以在web.debug.config里面添加以下内容,其意义在于替换web.config中变量Setting1的值。

于是,在选择项目生成时,若使用web.debug.config,如下图,生成的web role部署包中的web.config既是web.debug.config覆盖原有web.config的结果。这既是web config transformation技术,在传统.Net网站开发中经常使用。

回到主题:如何使用WCF服务来使得webrole.cs和网站进程w3wp交换信息呢?如下实现方式:

1. 添加一个WCF服务到网站项目中

2. 在新建的服务中添加一个新的方法和具体实现

        public string GetWebConfigSetting(string key)
        {
            string retVal = null;
            try
            {
                retVal = Properties.Settings.Default[key].ToString();
            }
            catch (Exception ex)
            {
            }
            return retVal;
        }

3. 在WebRole.cs中添加以下代码来读取web.config中的内容:

        public override void Run()
        {
            System.Diagnostics.Trace.WriteLine("Run function is called");

 

            //get content by consuming the service in target web process, here it goes
            try
            {
                ChannelFactory<IService1> factory = new ChannelFactory<IService1>(
                    new BasicHttpBinding(),
                    new EndpointAddress(new Uri("http://test1205.cloudapp.net/Service1.svc"))); //make sure test1205.cloudapp.net should be replaced by your cloud service DNS in your solution.
                IService1 channel = factory.CreateChannel();

                for (int i = 0; i < 10; i++)
                {
                    str = channel.GetWebConfigSetting("Setting1");
                    System.IO.File.AppendAllText("log.txt", "\r\n" + DateTime.Now.ToString() + "   got value --> " + str);
                    System.Threading.Thread.Sleep(1000);
                }
            }
            catch (Exception ex)
            {
                System.IO.File.AppendAllText("error.txt", "\r\n" + DateTime.Now.ToString() + "   got error --> " + ex.Message);
            }
            //end of reading configuration

            base.Run();
        }

 如此,WebRole.cs即WaIISHost进程就可以随时获取web进程中的信息。运行结果如下:

注意:此处的test1205.cloudapp.net需要替换成云服务所在的DNS,或者虚机的内网IP。

 

 (二)使用公有云缓存来共享信息

 http://blogs.msdn.com/b/jianwu/archive/2014/08/26/windows-azure-caching.aspx中介绍了公有云中常用的缓存技术,其中,角色辅助模式的缓存技术和托管模式的缓存技术实施方法几乎一致,因此,开发者可以使用缓存技术来实现数据预加载。如:

1. WebRole启动过程中加载字典或关键词库。

2. 网站(服务)在运行是依赖已加载的数据来处理业务逻辑。

 其中,加载数据的工作既可以通过预启动任务来完成,也可以通过WebRole.cs中的代码完成,本篇以后者为例进行实践。

选中网站和WebRole.cs所在的项目,右键管理Nugget包,搜索并安装Windows Azure Cache包。

安装完后,参考http://blogs.msdn.com/b/jianwu/archive/2014/08/26/windows-azure-caching.aspx,修改web.config中的dataCacheClients配置,使用role based cache或者managed cache,下面是使用托管式缓存。

<dataCacheClients>
  <dataCacheClient name="default">
    <!--To use the in-role flavor of Windows Azure Cache, set identifier to be the cache cluster role name -->
    <!--To use the Windows Azure Cache Service, set identifier to be the endpoint of the cache cluster -->
    <autoDiscover isEnabled="true" identifier="myzigcache.cache.windows.net" />
    <!--<localCache isEnabled="true" sync="TimeoutBased" objectCount="100000" ttlValue="300" />-->
    <!--Use this section to specify security settings for connecting to your cache. This section is not required if your cache is hosted on a role that is a part of your cloud service. -->
    <securityProperties mode="Message" sslEnabled="true">
        <messageSecurity authorizationInfo="Ykeymh[key]HA6L[key]0Lw==" />
      </securityProperties>
  </dataCacheClient>
</dataCacheClients>

然后在网站项目中,添加一个和webrole同名的配置文件,如示例中的 WCFServiceWebRole1.dll.config。

【重要】:之前的云服务架构博文中介绍过,WebRole.cs就会运行在WaIISHost进程中,其加载入口为用户代码所形成的库文件如WebRole1.dll(WCFServiceWebRole1.dll),因此添加的配置文件WebRole1.dll.config或WCFServiceWebRole1.dll.config能被WaIISHost进程所读取。

 具体配置文件内容为:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="dataCacheClients" type="Microsoft.ApplicationServer.Caching.DataCacheClientsSection, Microsoft.ApplicationServer.Caching.Core" allowLocation="true" allowDefinition="Everywhere" />
    <section name="cacheDiagnostics" type="Microsoft.ApplicationServer.Caching.AzureCommon.DiagnosticsConfigurationSection, Microsoft.ApplicationServer.Caching.AzureCommon" allowLocation="true" allowDefinition="Everywhere" />
  </configSections>
  <dataCacheClients>
    <dataCacheClient name="default">
      <!--To use the in-role flavor of Windows Azure Cache, set identifier to be the cache cluster role name -->
      <!--To use the Windows Azure Cache Service, set identifier to be the endpoint of the cache cluster -->
      <autoDiscover isEnabled="true" identifier="myzigcache.cache.windows.net" />
      <!--<localCache isEnabled="true" sync="TimeoutBased" objectCount="100000" ttlValue="300" />-->
      <!--Use this section to specify security settings for connecting to your cache. This section is not required if your cache is hosted on a role that is a part of your cloud service. -->
      <securityProperties mode="Message" sslEnabled="true">
        <messageSecurity authorizationInfo="YWNz【key】Nh【key】Lw==" />
      </securityProperties>
    </dataCacheClient>
  </dataCacheClients>

</configuration>

 随后,即可在WebRole.cs中添加代码,开始预加载数据,如:

        public override bool OnStart()
        {

            //preload data for further use
            DataCache cache = new DataCache("default");
            try
            {
                cache.Add("mycache1", "Preloaded info from WebRole" + DateTime.Now.ToString());
                System.Threading.Thread.Sleep(2000);
                cache.Add("mycache2", "Preloaded info from WebRole" + DateTime.Now.ToString());
                System.Threading.Thread.Sleep(2000);
                cache.Add("mycache3", "Preloaded info from WebRole" + DateTime.Now.ToString());
                System.Diagnostics.Trace.WriteLine("Preloaded cache is done");
            }
            catch (Exception eex)
            {
                System.Diagnostics.Trace.WriteLine(eex.Message);
            }

            // For information on handling configuration changes
            // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.

            return base.OnStart();
        }

 这样以后,网站服务就可以使用这些预加载的数据了。如一个按钮的响应函数:

protected void Button3_Click(object sender, EventArgs e)
        {
            DataCache cache = new DataCache("default");
            object result = cache.Get("mycache1");
            TextBox2.Text += "\r\nRead content from Cache: [" + result.ToString() + "] at " + DateTime.Now.ToString();
        }

 运行结果如下:

(三)云中常用的数据交互方式

除了上述两种方式以外,还有一些间接但很常见的方法可以用于云服务中的数据交互。之前的PaaS实践的系列博文中就用到了这一点。大体分以下几种:

1. 使用同一个SQL Azure、Azure Storage等永久存储来连接不同的云服务进程(模块)。

2. 使用队列存储来交互信息(如storage queue, service bus queue)

3. 建立socket通信等传统的通信技术。以下是一个示例实现:(参考信息:http://msdn.microsoft.com/en-us/library/6y0e13d3(v=vs.110).aspx

服务端代码:

    class Program
    {
        static void Main(string[] args)
        {
            StartListening();
            Console.Read();
        }

        // Incoming data from the client.
        public static string data = null;
        public static void StartListening()
        {
            // Data buffer for incoming data.
            byte[] bytes = new Byte[1024];

            // Establish the local endpoint for the socket.
            // Dns.GetHostName returns the name of the
            // host running the application.
            IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
            IPAddress ipAddress = ipHostInfo.AddressList[0];
            IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 1048);
 
            // Create a TCP/IP socket.
            Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            // Bind the socket to the local endpoint and
            // listen for incoming connections.

            try
            {
                listener.Bind(localEndPoint);
                listener.Listen(10);

                // Start listening for connections.
                while (true)
                {
                    Console.WriteLine("Waiting for a connection... @" + localEndPoint.ToString());
                    // Program is suspended while waiting for an incoming connection.
                    Socket handler = listener.Accept();
                    data = null;
 
                    // An incoming connection needs to be processed.
                    for (int num = 0; num < 10000; num++)
                    {
                        while (true)
                        {
                            bytes = new byte[1024];
                            int bytesRec = handler.Receive(bytes);
                            data = Encoding.ASCII.GetString(bytes, 0, bytesRec);
                            if (data.IndexOf("<EOF>") > -1)
                            {
                                break;
                            }
                        }
 
                        // Show the data on the console.
                        //Console.WriteLine(num.ToString() + " Text received : {0}", data);
                        System.IO.File.AppendAllText("./socketserver.txt", "\r\n" + DateTime.Now.ToString() + " recvd --> " + data);
 
                        // Echo the data back to the client.
                        byte[] msg = Encoding.ASCII.GetBytes(data);
                        System.IO.File.AppendAllText("./socketserver.txt", "\r\n" + DateTime.Now.ToString() + " echo --> " + data);
                        handler.Send(msg);
                    }
                    handler.Shutdown(SocketShutdown.Both);
                    handler.Close();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
            Console.WriteLine("\nPress ENTER to continue...");
            Console.Read();
        }
    }

 

客户端代码:

    class Program
    {
        static void Main(string[] args)
        {
            StartClient();
            Console.Read();
        }

        public static void StartClient()
        {
            // Data buffer for incoming data.
            byte[] bytes = new byte[1024];

            // Connect to a remote device.
            try
            {
               // Establish the remote endpoint for the socket.
                // This example uses port 11000 on the local computer.
                IPHostEntry ipHostInfo = Dns.Resolve("<mycloudservice>.cloudapp.net");

                //ipHostInfo = Dns.Resolve(Dns.GetHostName());
                IPAddress ipAddress = ipHostInfo.AddressList[0];
                IPEndPoint remoteEP = new IPEndPoint(ipAddress, 1048);
 
                // Create a TCP/IP  socket.
                Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                int interval = 0;

                // Connect the socket to the remote endpoint. Catch any errors.
                try
                {
                    sender.Connect(remoteEP);
                    Console.WriteLine("Socket connected to {0}", sender.RemoteEndPoint.ToString());
 
                    while (true)
                    {
                        // Encode the data string into a byte array.
                        byte[] msg = Encoding.ASCII.GetBytes(DateTime.Now.ToString() + " : This is a test <EOF>");
                        // Send the data through the socket.
                        int bytesSent = sender.Send(msg);
                        System.IO.File.AppendAllText("./socket.txt", "\r\n" + DateTime.Now.ToString() + " sent --> " + Encoding.ASCII.GetString(msg, 0, msg.Length));

                        // Receive the response from the remote device.
                        int bytesRec = sender.Receive(bytes);
                        //Console.WriteLine("Echoed test = {0}", Encoding.ASCII.GetString(bytes, 0, bytesRec));
                        System.IO.File.AppendAllText("./socket.txt", "\r\n" + DateTime.Now.ToString() + " recvd --> " + Encoding.ASCII.GetString(bytes, 0, bytesRec));

                        interval += 5 * 60 * 1000; //5 minutes
                        System.Threading.Thread.Sleep(interval);
                    }

                    // Release the socket.
                    sender.Shutdown(SocketShutdown.Both);
                    sender.Close();
                }
                catch (ArgumentNullException ane)
                {
                    Console.WriteLine(DateTime.Now.ToString() + "ArgumentNullException : {0}", ane.ToString());
                }
                catch (SocketException se)
                {
                    Console.WriteLine(DateTime.Now.ToString() + "SocketException : {0}", se.ToString());
                }
                catch (Exception e)
                {
                    Console.WriteLine(DateTime.Now.ToString() + "Unexpected exception : {0}", e.ToString());
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
    }

 运行日志:

Here is log from client app:

2014/10/10 11:23:15 sent --> 2014/10/10 11:23:15 : This is a test <EOF>

2014/10/10 11:23:15 recvd --> 2014/10/10 11:23:15 : This is a test <EOF>

2014/10/10 11:28:15 sent --> 2014/10/10 11:28:15 : This is a test <EOF>

2014/10/10 11:28:15 recvd --> 2014/10/10 11:28:15 : This is a test <EOF>

 

Here is the log from server app:

2014/10/10 11:23:15 recvd --> 2014/10/10 11:23:15 : This is a test <EOF>

2014/10/10 11:23:15 echo --> 2014/10/10 11:23:15 : This is a test <EOF>

2014/10/10 11:28:15 recvd --> 2014/10/10 11:28:15 : This is a test <EOF>

2014/10/10 11:28:15 echo --> 2014/10/10 11:28:15 : This is a test <EOF>

 

 

Skip to main content