If you’re planning on migrating an application or building a new
one for Windows Azure, chances are that you’ll need storage. This is
where the Windows Azure SDK for PHP comes in handy: it gives you easy
access to the blob storage, table storage and queue services provided
by Windows Azure. You can download this SDK as a
stand-alone, open-source package that allows you to access storage
from both on-premises locations and your cloud application. If you’re
using the Eclipse plug-in we discussed earlier, you’ll find this API
is included.

The process of utilizing storage always starts with setting up
your credentials: an account name and a shared key (think of this as a
very long password). Then, you can use one of the specific classes
available for blob storage, table storage, or queue storage.

Here’s an example of blob storage in action. First, I create a
container (think of this as a virtual hard drive). Then, I upload a
file from my local hard drive to blob storage:

/** Microsoft_WindowsAzure_Storage_Blob */
require_once 'Microsoft/WindowsAzure/Storage/Blob.php';
$storageClient = new Microsoft_WindowsAzure_Storage_Blob();
$storageClient->createContainer('testcontainer');
// upload /home/maarten/example.txt to Windows Azure
$result = $storageClient->putBlob('testcontainer', 'example.txt', '/home/maarten/example.txt');

Reading the blob afterwards is fairly
straightforward:

/** Microsoft_WindowsAzure_Storage_Blob */
require_once 'Microsoft/WindowsAzure/Storage/Blob.php';
$storageClient = new Microsoft_WindowsAzure_Storage_Blob();
// download file to /home/maarten/example.txt
$storageClient->getBlob('testcontainer', 'example.txt', '/home/maarten/example.txt');

Table storage is a bit more complex. It’s like a very scalable
database that’s not bound to a schema, and has limited querying
possibilities. To use table storage, you’ll require some classes that
can be used both by your PHP application and Windows Azure table
storage. Here’s an example class representing a
person:

class Person extends Microsoft_WindowsAzure_Storage_TableEntity
{
  /**
   * @azure Name
   */
  public $Name;
  /**
   * @azure Age Edm.Int64
   */
  public $Age;
}

Inserting an instance of Person into the
table is as easy as creating a new instance and assigning it some
properties. After that, the table storage API in the Windows Azure SDK
for PHP allows you to insert the entity into a table named
testtable:

/** Microsoft_WindowsAzure_Storage_Table */
require_once 'Microsoft/WindowsAzure/Storage/Table.php';
$entity = new Person('partition1', 'row1');
$entity->Name = "Maarten";
$entity->Age = 25;
$storageClient = new Microsoft_WindowsAzure_Storage_Table('table.core.windows.net', 'myaccount', 'myauthkey');
$storageClient->insertEntity('testtable', $entity);

That was a lot of information in one code snippet! First of all,
what are partition1 and row1? Well,
those are the partition key and row key. The partition
key is a logical grouping of entities. In an application
where users can contribute blog posts, for example, a good candidate
for the partition key would be the username—this would allow you to
easily query for all data related to a given user. The row
key is the unique identifier for the row.

Queues follow the same idea—there’s an API that allows you to
put, get, and delete messages from the queue on Windows Azure. Queues
are also guaranteed to be processed: when a message is read from the
queue, data is made invisible for a specific time. If, after that
time, the message has not been explicitly removed, for example because
a batch script has crashed, the message will re-appear and be
available for processing again.

The Windows Azure SDK for PHP also has some extra features that
are specific to both PHP and Windows Azure. This includes features
like a session storage provider that allows you to share web session
data over multiple web role instances. Another feature is a stream
wrapper that allows you to use standard file functions like
fopen on blob storage.

An example application, ImageCloud, which uses all the features
described above, is available
for download on my blog.

The SQL Server Driver for PHP allows PHP developers to access
SQL Server databases that are hosted on SQL Server or SQL Azure. The
SQL Server Driver for PHP relies on the Microsoft SQL Server ODBC
Driver to handle low-level communication with SQL Server. As a result,
the SQL Server Driver for PHP is only supported on Windows and Windows
Azure. It can be downloaded and installed
as a PHP extension.

When you download this driver, be sure to download version 2.0.
This version has the additional benefit that it provides PDO (PHP Data
Objects) support, which allows you to quickly switch between, for
example, MySQL and SQL Server.

Now, let’s imagine you have an SQL Azure database. The following
code shows how you can connect to the blog database
on your SQL Azure database server and retrieve the posts ordered by
publication date:

// Connect to SQL Azure using PDO
$connection = new PDO('bvoj6aovnk.database.windows.net', 'sqladm@bvoj6aovnk', 'mypassword', array('Database' => 'blog'));
// Fetch specific post
$posts = array();
$query = 'SELECT * FROM posts ORDER BY PubDate DESC';
$statement = $connection->query($query);
while ( $row = $statement->fetchObject('Post') ) {
  $posts[] = $row;
}

As I mentioned before, the Windows Azure Platform AppFabric (not
to be confused with the Windows Server AppFabric) enables you to
delegate user authentication and authorization, and to punch firewalls
and connect applications across different protected networks with
ease. You can download it from http://dotnetservicesphp.codeplex.com.

In terms of authentication and authorization, it’s important to
know a little about claims-based authentication and federation—a topic
on which some interesting
resources are available. Basically, your application
establishes a trust relationship with an authentication authority
(like Windows Azure Platform AppFabric), which means that your
application trusts users that are authenticated with that authority.
Next, your application will ask its users to claim their rights. For
example, my application could ask the user to claim that they can
create orders:

$requiredClaims = array('CreateOrder' => true);
if (ValidateClaimUtil::ValidateClaims($requiredClaims, "phpservice", 'http://localhost/SalesDashboard/', $signingKey))
{
  // User is allowed to create an order!
}
else
{
  // User is not authorized.
}

The Windows Azure Platform AppFabric Access Control Service will
validate that the user has this claim, and sign a security token with
that information. Since your application trusts this authority, it
will either continue or fail on the basis of whether or not the claim
is valid.

Now magine having two applications that cannot connect to each
other because of firewall-related policies. If both applications can
establish an outgoing connection to the service bus, the service bus
will relay communication between the two applications. It’s as easy as
that—and incredibly useful if you have a tough IT department!

Figure 3. The benefits of Windows Azure Platform AppFabric Service
Bus

Showing you example code of how this works would lead us too far
(since it would involve some configuration and set up tasks). But if
you think this sounds like a great feature, check the AppFabric for PHP
website, which contains plenty of tutorials on this
matter.

The Windows Azure platform provides some useful features, like
reading configuration files (which can be modified even after a
deployment has been done), or logging into the Windows Azure
environment and accessing local storage on a virtual machine to store
files temporarily. Unfortunately, these features are baked in to the
Windows Azure Cloud Guest OS, and not available as REST services.
Luckily however, these features are exposed as a C dynamic link
library, which means that writing a PHP extension to interface with
them is a logical step. And that’s exactly what the PHP Azure
Contributions library provides: a PHP extension to make use of
configuration data, logging, and local storage. Imagine having a
configuration value named EmailSubject in your
ServiceConfiguration.csdef file. Reading this
value is very easy using the PHP Azure Contributions extension:

$$emailSubject = azure_getconfig("EmailSubject");

We can also write data to the Windows Azure diagnostics log.
Here’s an example in which I’m writing an informational message in the
diagnostics log:

azure_log("This is some useful information!", "Information");

The PHP Azure Contributions project is available on CodePlex at
http://phpazurecontrib.codeplex.com.

As a PHP developer, you may already use URL rewriting. In
Apache’s .htaccess files, it’s very easy to
enable the rewrite engine, and to rewrite incoming URLs to real
scripts. For example, the URL
http://www.example.com/products/books may be mapped to
http://www.example.com/index.php?page=products&category=books
on your server. This technique is also available in IIS7, the
Microsoft web server that’s also used in Windows Azure web roles. The
above URL rewriting example can be defined in the
Web.config file in the root of your Windows Azure
application:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <system.webServer>
    <rewrite>
      <rules>
        <rule name="RewriteProductsUrl" enabled="true" stopProcessing="true">
          <match url="^products/([^/]+)/?$" />
          <conditions>
            <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
            <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
          </conditions>
          <action type="Rewrite" url="index.php?page=products&category={R:1}" />
        </rule>
      </rules>
    </rewrite>
  </system.webServer>
</configuration>

Also note that, because your application is hosted on an IIS web
server in Windows Azure, you can use any HttpModule for IIS, just as
you would for a traditionally hosted application. This makes it easy
to enable output compression, leverage the IIS authentication and
authorization features, and more. Download the IIS URL Rewrite module
from http://www.iis.net/download/urlrewrite.

As you may know, PHP files are interpreted into bytecode and
executed from that bytecode on every request. This process is quite
fast, but on high-traffic websites, it’s recommended that we cache the
bytecode and skip script interpretation. This technique increases a
website’s performance without requiring additional resources.

On Linux, accelerator modules that utilize these techniques,
like APC and IonCube, are very common. These also work on Windows and
could potentially also work on Windows Azure. However, Microsoft also
released its own module that applies this technique: the WinCache
extension for PHP. This extension is the fastest PHP accelerator on
Windows, and also provides features like storing session data in this
cache layer. The Wincache extension for PHP can be downloaded from
http://www.iis.net/download/wincacheforphp.

When using Windows Azure blob storage, you’ll find that a
full-featured content delivery network (CDN) is available as well. A
CDN ensures that, for example, when a user downloads an image, that
image will be retrieved from a storage server that’s close to that
user’s client. This ensures that the download speed and latency are
optimal, and the user receives the image very quickly.

With blob storage, enabling the CDN is as easy as clicking a
button. After that, your public containers are replicated to the CDN,
which allows your site’s users to retrieve files and resources as
swiftly as possible!

Figure 4. Using the Windows Azure CDN

With Windows Azure, your application will be assigned a domain
name under the cloudapp.net domain—for example,
myphpapp.cloudapp.net. I think you’ll agree that this isn’t
the greatest URL. It gets even worse when you’re using blob storage
for hosting files: myphpappstorage.blob.core.windows.net
is, well, just plain ugly!

Luckily, all URLs in Windows Azure can be mapped a custom domain
name. So, to map www.myphpapp.com to
myphpapp.cloudapp.net, you just need to add a CNAME record
to your name server. The same applies to blob storage:
storage.myphpapp.com can be mapped to the very long
myphpappstorage.blob.core.windows.net through the addition
of a CNAME record to your DNS server.

Check Azure team member Steve
Marx’s post on custom domain names for more on this.