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: 

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.

Raw Notes:

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 account, and that way I can search them from anywhere. I can even read them on the web, since the 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.

  1. Programming Windows Azure by Siriram Krishnan: Learning about how to select applications suitable for Distributed Technology.
    1. Application Fabric gets the least attention; probably because it was newer at the time.
    2. Very clear (Chapter One)
    3. Good foundation
    4. Background and history, but not too much
    5. I normally arrange my descriptions differently, starting with the use-cases and moving to physicality, but this difference helps me.
    6. Interesting that I am reading this using Safari Books Online, which uses many of these concepts.
    7. 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)
    8. Good detail of what is included in the SDK. Even more is available now. CS = Cloud Service (Chapter 3)
    9. 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)
    10. There are two Runtime API’s, one of external and one for internal.
    11. Realizing how powerful this paradigm really is.
    12. Some places seem light, and to drop off but perhaps that’s best.
    13. 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)
    14. Csmanage is something I want to dig into deeper. API requires package moves to Blob storage first, so it needs a URL.
    15. Csmanage equivalent can be written in Unix scripting using openssl.
    16. Upgrades are possible, and you use the upgradeDomainCount attribute in the Service-Definition.csdef file
    17.  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)
    18. 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.
    19. 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.
    20. 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)
    21. REST API makes the service interoperable, hybrid, and consistent across code architectures. Nicely done.
    22. Use affinity groups to keep data and code together.
    23. Side note: e-book readers need a common “notes” feature.
    24. There’s a decent quick description of REST in this chapter.
    25. 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.
    26. Good treatment in the storage chapters on the differences between using Dev storage and Azure storage. These can be mitigated.
    27. No, blobs are not of any size or number. Not a good statement (Chapter 8)
    28. Blob storage is probably Azure’s closest play to Infrastructure as a Service (Iaas).
    29. Blob change operations must be authenticated, even when public.
    30. Chapters on storage are pretty in-depth.
    31. Queue Messages are base-64 encoded (Chapter 9)
    32. The visibility timeout ensures processing of message in a disconnected system.
    33. Order is not guaranteed for a message, so if you need that set an increasing number in the queue mechanism.
    34. While Queues are accessible via REST, they are not public and are secured by default.
    35. Interesting – the header for a queue request includes an estimated count. This can be useful to create more worker roles in a dynamic system.
    36. Each Entity (row) in the Azure Table service is atomic – all or nothing. (Chapter 10)
    37. An entity can have up to 255 Properties
    38.  Use “ID” for the class to indicate the key value, or use the [DataServiceKey] Attribute.
    39.  LINQ makes working with the Azure Table Service much easier, although Interop is certainly possible.
    40. Good description on the process of selecting the Partition and Row Key.
    41.  When checking for continuation tokens for pagination, include logic that falls out of the check in case you are at the last page.
    42.  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.
    43. 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.
    44.  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)
    45.  Presents a better discussion of indexes (at least inverted indexes) later in the chapter.
    46. Great treatment for DBA’s in Chapter 11.
    47. We need to work on getting secondary indexes in Table storage.
    48. There is a limited form of transactions called “Entity Group Transactions” that, although they have conditions, makes a transactional system more possible.
    49. 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.
    50. 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.
    51. Chapter seems out of place, and should be combined with the Blob chapter.
    52.  (Chapter 13) on SQL Azure is dated, although the base concepts are OK.
    53.  Nice example of simple ADO.NET access to a SQL Azure (or any SQL Server Really) database.