Book Review (Book 1) - Programming Windows Azure by Siriram Krishnan
As part of my professional development, I’ve created a list of books to read throughout the year, starting in June of 2011. This a review of the first one, called Programming Windows Azure by Siriram Krishnan. You can find my entire list of books I’m reading for my career here: http://blogs.msdn.com/b/buckwoody/archive/2011/06/07/head-in-the-clouds-eyes-on-the-books.aspx
Why I Chose This Book:
As part of my learning style, I try to read multiple books about a single subject. I’ve found that at least 3 books are necessary to get the right amount of information to me. This is a “technical” work, meaning that it deals with technology and not business, writing or other facets of my career. I’ll have a mix of all of those as I read along.
I chose this work in addition to others I’ve read since it covers everything from an introduction to more advanced topics in a single book. It also has some practical examples of actually working with the product, particularly on storage. Although it’s dated, many examples normally translate. I also saw that it had pretty good reviews.
What I learned:
I learned a great deal about storage, and many useful code snippets. I do think that there could have been more of a focus on the application fabric - but of course that wasn’t as mature a feature when this book was written. I learned some great architecture examples, and in one section I learned more about encryption. In that example, however, I would rather have seen the examples go the other way - the book focused on moving data from on-premise to Azure storage in an encrypted fashion. Using the Application Fabric I would rather see sensitive data left in a hybrid fashion on premise, and connect to for the Azure application. Even so, the examples were very useful.
If you’re looking for a good “starter” Azure book, this is a good choice. I also recommend the last chapter as a quick read for a DBA, or Database Administrator. It’s not very long, but useful. Note that the limits described are incorrect - which is one of the dangers of reading a book about any cloud offering. The services offered are updated so quickly that the information is in constant danger of being “stale”. Even so, I found this a useful book, which I believe will help me work with Azure better.
I take notes as I read, calling that process “reading with a pencil”. I find that when I do that I pay attention better, and record some things that I need to know later. I’ll take these notes, categorize them into a OneNote notebook that I synchronize in my Live.com account, and that way I can search them from anywhere. I can even read them on the web, since the Live.com has a OneNote program built in. Note that these are the raw notes, so they might not make a lot of sense out of context - I include them here so you can watch my though process.
- Programming Windows Azure by Siriram Krishnan: Learning about how to select applications suitable for Distributed Technology.
- Application Fabric gets the least attention; probably because it was newer at the time.
- Very clear (Chapter One)
- Good foundation
- Background and history, but not too much
- I normally arrange my descriptions differently, starting with the use-cases and moving to physicality, but this difference helps me.
- Interesting that I am reading this using Safari Books Online, which uses many of these concepts.
- Taught me some new aspects of a Hypervisor – very low-level information about the Azure Fabric (not to be confused with the Application Fabric feature) (Chapter Two)
- Good detail of what is included in the SDK. Even more is available now. CS = Cloud Service (Chapter 3)
- Place Storage info in the configuration file, since it can be streamed in-line with a running app. Ditto for logging, and keep separated configs for staging and testing. Easy-switch in and switch out. (Chapter 4)
- There are two Runtime API’s, one of external and one for internal.
- Realizing how powerful this paradigm really is.
- Some places seem light, and to drop off but perhaps that’s best.
- Managing API is not charged, which is nice. I don’t often think about the price, until it comes to an actual deployment (Chapter 5)
- Csmanage is something I want to dig into deeper. API requires package moves to Blob storage first, so it needs a URL.
- Csmanage equivalent can be written in Unix scripting using openssl.
- Upgrades are possible, and you use the upgradeDomainCount attribute in the Service-Definition.csdef file
- Always use a low-privileged account to test on the dev fabric, since Windows Azure runs in partial trust. Full trust is available, but can be dangerous and must be well-thought out. (Chapter 6)
- Learned how to run full CMD commands in a web window – not that you would ever do that, but it was an interesting view into those links.
- This leads to a discussion on hosting other runtimes (such as Java or PHP) in Windows Azure. I got an expanded view on this process, although this is where the book shows its age a little. Books can be a problem for Cloud Computing for this reason – things just change too quickly.
- Windows Azure storage is not eventually consistent – it is instantly consistent with multi-phase commit. Plumbing for this is internal, not required to code that. (Chapter 7)
- REST API makes the service interoperable, hybrid, and consistent across code architectures. Nicely done.
- Use affinity groups to keep data and code together.
- Side note: e-book readers need a common “notes” feature.
- There’s a decent quick description of REST in this chapter.
- Learned about CloudDrive code – PowerShell sample that mounts Blob storage as a local provider. Works against Dev fabric by default, can be switched to Account.
- Good treatment in the storage chapters on the differences between using Dev storage and Azure storage. These can be mitigated.
- No, blobs are not of any size or number. Not a good statement (Chapter 8)
- Blob storage is probably Azure’s closest play to Infrastructure as a Service (Iaas).
- Blob change operations must be authenticated, even when public.
- Chapters on storage are pretty in-depth.
- Queue Messages are base-64 encoded (Chapter 9)
- The visibility timeout ensures processing of message in a disconnected system.
- Order is not guaranteed for a message, so if you need that set an increasing number in the queue mechanism.
- While Queues are accessible via REST, they are not public and are secured by default.
- Interesting – the header for a queue request includes an estimated count. This can be useful to create more worker roles in a dynamic system.
- Each Entity (row) in the Azure Table service is atomic – all or nothing. (Chapter 10)
- An entity can have up to 255 Properties
- Use “ID” for the class to indicate the key value, or use the [DataServiceKey] Attribute.
- LINQ makes working with the Azure Table Service much easier, although Interop is certainly possible.
- Good description on the process of selecting the Partition and Row Key.
- When checking for continuation tokens for pagination, include logic that falls out of the check in case you are at the last page.
- On deleting a storage object, it is instantly unavailable, however a background process is dispatched to perform the physical deletion. So if you want to re-create a storage object with the same name, add retry logic into the code.
- Interesting approach to deleting an index entity without having to read it first – create a local entity with the same keys and apply it to the Azure system regardless of change-state.
- Although the “Indexes” description is a little vague, it’s interesting to see a Folding and Stemming discussion a-la the Porter Stemming Algorithm. (Chapter 11)
- Presents a better discussion of indexes (at least inverted indexes) later in the chapter.
- Great treatment for DBA’s in Chapter 11.
- We need to work on getting secondary indexes in Table storage.
- There is a limited form of transactions called “Entity Group Transactions” that, although they have conditions, makes a transactional system more possible.
- Concurrency also becomes an issue, but is handled well if you’re using Data Services in .NET. It watches the Etag and allows you to take action appropriately.
- I do not recommend using Azure as a location for secure backups. In fact, I would rather have seen the examples in (Chapter 12) go the other way, showing how data could be brought back to a local store as a DR or HA strategy. Good information on cryptography and so on even so.
- Chapter seems out of place, and should be combined with the Blob chapter.
- (Chapter 13) on SQL Azure is dated, although the base concepts are OK.
- Nice example of simple ADO.NET access to a SQL Azure (or any SQL Server Really) database.