Running Memcached on Windows Azure for PHP

After three conferences in two weeks with a lot of “airport time”, which typically converts into “let’s code!” time, I think I may have tackled a commonly requested Windows Azure feature for PHP developers. Some sort of distributed caching is always a great thing to have when building scalable services and applications. While Windows Azure offers a distributed caching layer under the form of the Windows Azure Caching, that components currently lacks support for non-.NET technologies. I’ve heard there’s work being done there, but that’s not very interesting if you are building your app today. This blog post will show you how to modify a Windows Azure deployment to run and use Memcached in the easiest possible manner.

Note: this post focuses on PHP but can also be used to setup Memcached on Windows Azure for NodeJS, Java, Ruby, Python, …

Related downloads:
The scaffolder source code: MemcachedScaffolderSource.zip (1.12 mb)
The scaffolder, packaged and ready for use: MemcachedScaffolder.phar (2.87 mb)

The short version: use my scaffolder

As you may know, when working with PHP on Windows Azure and when making use of the Windows Azure SDK, you can use and create scaffolders. The Windows Azure SDK for PHP includes a powerful scaffolding feature that allows users to quickly setup a pre-packaged and configured website ready for Windows Azure.

If you want to use Memcached in your project, do the following:

• Download my custom MemcacheScaffolder (MemcachedScaffolder.phar (2.87 mb)) and make sure it is located either under the scaffolders folder of the Windows Azure SDK for PHP, or that you remember the path to this scaffolder
• Run the scaffolder from the command line: (note: best use the latest SVN version of the command line tools)

1 scaffolder run -out="c:\temp\myapp" -s="MemcachedScaffolder"

1 require_once 'memcache.inc.php'; 

That’s it!

The long version: what this scaffolder does behind the scenes

Of course, behind this “developers can simply use 1 line of code” trick a lot of things happen in the background. Let’s go through the places I’ve made changes from the default scaffolder.

The ServiceDefinition.csdef file

Let’s start with the beginning: when running Memcached in a Windows Azure instance, you’ll have to specify it with a port number to use. As such, the ServiceDefinition.csdef file which defines what the datacenter configuration for your app should be looks like the following:

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <ServiceDefinition name="PhpOnAzure" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
 3   <WebRole name="PhpOnAzure.Web" enableNativeCodeExecution="true">
 4     <Sites>
 5       <Site name="Web" physicalDirectory="./PhpOnAzure.Web">
 6         <Bindings>
 7           <Binding name="Endpoint1" endpointName="HttpEndpoint" />
 8         </Bindings>
 9       </Site>
10     </Sites>
11     <Startup>
12       <Task commandLine="add-environment-variables.cmd" executionContext="elevated" taskType="simple" />
13       <Task commandLine="install-php.cmd" executionContext="elevated" taskType="simple">
14         <Environment>
15           <Variable name="EMULATED">
16             <RoleInstanceValue xpath="/RoleEnvironment/Deployment/@emulated" />
17           </Variable>
18         </Environment>
19       </Task>
20       <Task commandLine="memcached.cmd" executionContext="elevated" taskType="background" />
21       <Task commandLine="monitor-environment.cmd" executionContext="elevated" taskType="background" />
22     </Startup>
23     <Endpoints>
24       <InputEndpoint name="HttpEndpoint" protocol="http" port="80" />
25       <InternalEndpoint name="MemcachedEndpoint" protocol="tcp" />
26     </Endpoints>
27     <Imports>
28       <Import moduleName="Diagnostics"/>
29     </Imports>
30     <ConfigurationSettings>
31     </ConfigurationSettings>
32   </WebRole>
33 </ServiceDefinition>

Note the <InternalEndpoint name="MemcachedEndpoint" protocol="tcp" /> line of code. This one defines that the web role instance should open some TCP port in the firewall with the name MemcachedEndpoint and expose that to the other virtual machines in your deployment. We’ll use this named endpoint later when starting Memcached.

Something else in this file is noteworthy: the startup tasks under the <Startup> element. With the default scaffolder, the first two tasks (namely add-environment-variables.cmd and install-php.cmd) are also present. These do nothing more than providing some environment information about your deployment in the environment variables. The second one does what its name implies: install PHP on your virtual machine. The latter two scripts added, memcached.cmd and monitor-environment.cmd are used to bootstrap Memcached. Note these two tasks run as background tasks: I wanted to have these two always running to ensure when Memcached crashes the task can simply restart Memcached.

The php folder

If you’ve played with the default scaffolder in the Windows Azure SDK for PHP, you probably know that the PHP installation in Windows Azure is a “default” one. This means: no memcached extension is in there. To overcome this, simply copy the correct php_memcache.dll extension into the /php/ext folder and Windows Azure (well, the install-php.cmd script) will know what to do with it.

Memcached.cmd and Memcached.ps1

Under the application’s bin folder, I’ve added some additional startup tasks. The one responsible for starting (and maintaining a running instance of) Memcached is, of course, Memcached.cmd. This one simply delegates the call to Memcached.ps1, of which the following is the source code:

1 [Reflection.Assembly]::LoadWithPartialName("Microsoft.WindowsAzure.ServiceRuntime")
2 
3 # Start memcached. To infinity and beyond!
4 while (1) {
5     $p = [diagnostics.process]::Start("memcached.exe", "-m 64 -p " + [Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment]::CurrentRoleInstance.InstanceEndpoints["MemcachedEndpoint"].IPEndpoint.Port)
6     $p.WaitForExit()
7 }

To be honest, this file is pretty simple. It loads the WindowsAzure ServiceRuntime assembly which contains all kinds of information about the current deployment. Next, I start an infinite loop which continuously starts a new memcached.exe process consuming 64MB of RAM memory and listens on the port specified by the MemcachedEndpoint defined earlier.

Monitor-environment.cmd and Monitor-environment.ps1

The monitor-environment.cmd script takes the same approach as the memcached.cmd script: just pass the command along to a PowerShell script in the form of monitor-environment.ps1. I do want to show you the monitor-environment.cmd script however, as there’s one difference in there: I’m changing the file system permissions for my application (the icacls line).

1 @echo off
2 cd "%~dp0"
3 
4 icacls %RoleRoot%\approot /grant "Everyone":F /T
5 
6 powershell.exe Set-ExecutionPolicy Unrestricted
7 powershell.exe .\monitor-environment.ps1

The reason for changing permissions is simple: I want to make sure I can write a PHP script to disk every minute. Yes, you heard me! I’m using PowerShell (in the monitor-environment.ps1 script) to generate PHP code. Here’s the PowerShell:

 1 [Reflection.Assembly]::LoadWithPartialName("Microsoft.WindowsAzure.ServiceRuntime")
 2 
 3 # To infinity and beyond!
 4 
 5 while(1) {
 6     ##########################################################
 7     # Create memcached include file for PHP
 8     ##########################################################
 9 
10     # Dump all memcached endpoints to ../memcached-servers.php
11     $memcached = "<?php`r`n"
12     $memcached += "`$memcachedServers = array("
13 
14     $currentRolename = [Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment]::CurrentRoleInstance.Role.Name
15     $roles = [Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment]::Roles
16     foreach ($role in $roles.Keys | sort-object) {
17         if ($role -eq $currentRolename) {
18             $instances = $roles[$role].Instances
19             for ($i = 0; $i -lt $instances.Count; $i++) {
20                 $endpoints = $instances[$i].InstanceEndpoints
21                 foreach ($endpoint in $endpoints.Keys | sort-object) {
22                     if ($endpoint -eq "MemcachedEndpoint") {
23                         $memcached += "array(`""
24                         $memcached += $endpoints[$endpoint].IPEndpoint.Address
25                         $memcached += "`" ,"
26                         $memcached += $endpoints[$endpoint].IPEndpoint.Port
27                         $memcached += "), "
28                     }
29 
30 
31                 }
32             }
33         }
34     }
35 
36     $memcached += ");"
37 
38     Write-Output $memcached | Out-File -Encoding Ascii ../memcached-servers.php
39 
40     # Restart the loop in 1 minute
41     Start-Sleep -Seconds 60
42 }

The output is being written every minute to the memcached-servers.php file. Why every minute? Well, if servers are added or removed I want my application to use the correct set of servers. This leaves a possible gap of one minute where some server may not be available, you can easily catch any error related to this in your PHP code (or add a comment to this blog post telling me what’s a better interval). Anyway, here’s the sample output:

1 <?php
2 $memcachedServers = array(array('10.0.0.1', 11211), array('10.0.0.2', 11211), );

All there’s left to do is consume this array. I’ve added a default memcache.inc.php file in the root of the web role to make things easy:

1 <?php
2 require_once $_SERVER["RoleRoot"] . '\\approot\\memcached-servers.php';
3 $memcache = new Memcache();
4 foreach ($memcachedServers as $memcachedServer) {
5     if (strpos($memcachedServer[0], '127.') !== false) {
6         $memcachedServer[0] = 'localhost';
7     }
8     $memcache->addServer($memcachedServer[0], $memcachedServer[1]);
9 }

Include this file in your code and you have a full-blown distributed cache available in your Windows Azure deployment! Here’s a sample of some operations that can be done on Memcached:

 1 <?php
 2 error_reporting(E_ALL);
 3 require_once 'memcache.inc.php';
 4 
 5 var_dump($memcachedServers);
 6 var_dump($memcache->getVersion());
 7 
 8 $memcache->set('key1', 'value1', false, 30);
 9 echo $memcache->get('key1');
10 
11 $memcache->set('var_key', 'some really big variable', MEMCACHE_COMPRESSED, 50);
12 echo $memcache->get('var_key');

That’s it!

Conclusion and feedback

This is just a fun project I’ve been working on when lonely and bored on airports. However, if you think this is valuable and in your opinion should be made available as a standard thing in the Windows Azure SDK for PHP, let me know. I’ll be happy to push this into the main branch and make sure it’s available in a future release.

Comments or praise? There’s a comment form right below this post!

This is an imported post. It was imported from my old blog using an automated tool and may contain formatting errors and/or broken images.