I will be focusing on some of these free cloud hosting options available out there. One thing to note before you proceed - these free cloud hosting options are very good to develop and test your applications (in dev+staging environment) and it may not be wise to deploy the production version of your application with any free plan (Except Amazon AWS's free tier, its production ready).

He has four different services on his list, ranging anywhere from small to industrial strength, depending on your needs:

• Amazon's AWS
• PHPFog
• PHPCloud (from Zend)
• Heroku (traditionally Ruby, now supports PHP too)

I've been working with OAuth, as a provider and consumer, and there isn't a lot of documentation around it for PHP at the moment so I thought I'd share my experience in this series of articles. [...] This entry follows on from the ones about the initial requirements, how to how to handle request tokens, and authenticating users.

In this latest post, she talks about the three different types of tokens - consumer, request and verififier - and how to use them to locate a user in your app's users. Her code validates the request token and verifier against the database and, if successful, inserts the rest of the token information for the user.

Zend Framework has pretty good OAuth consumer implementation. However, it has no support for implementing OAuth provider, and it turns out that there aren't many other libraries for it. Most examples out there base on PECL oauth extension, which works just fine, with one caveat - you have to have this PECL extension installed, while ZF implementation does not require that. So I went ahead and wrote some code that allows to easily add OAuth provider to your ZF-based or ZF-using application. That should make writing OAuth provider easier.

His code just fleshes out the server portion of the provider, not all of the token generation and key handling it'll need on the backend - that'll still be the job of your scripts. You can find the library over on github in his Zend_OAuth_Provider repository.

This phase is probably the most familiar to us as developers, as it's simply a login form. The consumer will send the user to us at the URL we provided in the request token, and the user will have the request token key as a parameter. The access control on this page will look the same as on the rest of the website; if the user has a session already then the page is displayed, otherwise they must be logged in to see it.

She talks about verifying the authentication token passed in (from the value already generated and put into a database table), the grant/deny process and the information to update in her sample table when the user falls into the "granted" side of things. She also briefly mentions the optional callback that can be passed to a service like this and how to handle its value.

The consumer requests a request token (see my earlier post about consuming OAuth), and as a provider, we need to handle that request. In my example, I chose to pass the variables as GET parameters, but you could adapt this to handle POST variables or information contained in HTTP headers.

She includes the code (using the functionality of the pecl_oauth extension) to provide a token and the three functions you'll need to define to get things working - the consumerHandler, the tokenHandler and timestampNonceHandler. She also includes a sample database table structure for storing the OAuth information for a user.

This article uses the pecl_oauth extension and builds on Rasmus' OAuth Provider post. [...] OAuth has a little more baggage with it than just passing a username and password to an API.

She lists the five things you'll need for your service and talks a bit about the registration process and how the consumer key/consumer secret keys are generated. There's no strict definition on them, so her example uses a combination of sha1, mt_rand and substr to get the job done. She also includes a sample "consumers" table for your reference.

I've started playing with the development versions of ZF 2.0 and one of the first things I thought I'd do was to port Akrabat_Db_Schema_Manager. It turned out to be reasonably easy. All I needed to do was rework my use of ZF components to use the new ZF2 ones. Whilst I was at it, I also converted it to use namespaces. I also had to reorganise the http://github.com/akrabat/Akrabat library so that I could have ZF1 and ZF2 code in it.

He includes "before" and "after" snippets of code to help illustrate the example. He had to change up things just a bit to handle the namespaces because of naming issues (a class named "Abstract" isn't allowed). If you want to see more of the updated code, you can check out his account on github with the changes.

During [a workshop at Symfony Live] workshop, Stefan demonstrated creating Symfony "tasks". These are classes that tie in to the Symfony command-line tooling -- basically allowing you to tie in to the CLI tool in order to create cronjobs, migration scripts, etc. Of course, Zend Framework has an analogue to Symfony tasks in the Zend_Tool component's "providers". In this post, I'll demonstrate how you can create a simple provider that will return the most recent entry from an RSS or Atom feed.

He shows how to create a sample provider - one that grabs data from two RSS feeds and outputs them - complete with code example, adding the provider someplace where Zend_Tool can find it and using the provider through the command-line "zf" tool.

Last year I showed how to use pecl/oauth to write a Twitter OAuth Consumer. But what about writing the other end of that? What if you need to provide OAuth access to an API for your site? How do you do it? Luckily John Jawed and Tjerk have put quite a bit of work into pecl/oauth lately and we now have full provider support in the extension. It's not documented yet at php.net/oauth, but there are some examples in svn.

He walks you through creating the consumer key registration page (so others can signup for access to your provider), making the OAuth endpoints, how to authorize the request token and send back out the access token. He also includes an actual API call to show it working.

One of the cool things about Zend Framework is it's cli tool, Zend_Tool. (zf) When zf works, it's awesome. However, when it breaks, it's a real pain in the butt. [...] Even though it's made great strides, setting up zf is still not seamless. To that end, here is my list of steps needed to setup zf.

He's using XAMPP on a Windows 7 machine and has a list of eight steps you'll need to follow to get Zend_Tool playing happily including locating certain directories (your general path, the path to your php.exe) and a few commands to tell the Zend Framework where to correctly deposit its files. If all goes well, you'll get this kind of result (screenshot). He mentions a slight problem, though - defining your own providers and them not being recognized. It can be corrected, though, using this handy tip.