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

Article
10/09/2014

在https://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("https://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。

（二）使用公有云缓存来共享信息

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

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

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

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

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

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

然后在网站项目中，添加一个和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">
      
      
      <autoDiscover isEnabled="true" identifier="myzigcache.cache.windows.net" />
      
      
      <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 https://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通信等传统的通信技术。以下是一个示例实现：（参考信息：https://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>

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

Additional resources