If you are checking out the repos on GitHub you will see some new NG repos where we will be working and making some adjustments. These are working repos so please be careful when you use them.

https://github.com/IronFoundry/dea_ng

https://github.com/IronFoundry/cloud_controller_ng

Our current plan next week is to enable a board to keep track of progress.

Today, we’ve updated the Micro Iron Foundry instance to ensure compatibility with the latest version of Micro Cloud Foundry. Download the VMX or OVF image now and plug it into your existing Micro Cloud Foundry image. In addition to updating the image to the most recent Cloud Foundry-friendly bits, we’ve also made three other notable changes:

• Microsoft .NET 4.5 support. The latest version of the .NET framework includes a number of cool improvements from Web Sockets support, to better Windows Identity Foundation capabilities, to access to the new ASP.NET Web API. Micro Iron Foundry is running .NET 4.5 and soon you’ll see this support in IronFoundry.ME and other hosting environments.
• DEA compatible with latest ActiveState Stackato. We’ve ensured that this new Micro Iron Foundry instance works great with the very latest Stackato Micro Cloud. See our previous blog post on how to connect ActiveState’s great product to a Micro Cloud Foundry + Micro Iron Foundry setup.
• Standard vmc gem works against Iron Foundry applications. You no longer need to use the vmc-IronFoundry gem in order to push .NET applications to your Iron Foundry DEA in Micro Iron Foundry. Note that you still need this gem when pushing applications to IronFoundry.ME and other Iron Foundry hosting environments.

Check it out and let us know if you have any problems!

Now, from either Visual Studio 2010 or Visual Studio 2010, developers can push .NET 4.0 apps to any Iron Foundry-compliant endpoint.

ASP.NET web applications (or WCF services) can be deployed or redeployed from this tool,. In addition, developers can see all the applications deployed to a given Iron Foundry cloud, and even change resource allocations for a given application.

Feel free to go download this latest Visual Studio extension today!

What is Windows Azure ACS?

Windows Azure ACS is essential a claims transformation engine that connects to trusted web identity providers (e.g. Facebook, Google, Windows Live, Yahoo) and custom identity providers (e.g. through Active Directory Federation Services), and authenticates the user before passing along a set of claims to your web application. It provides developers a way to outsource the identity management part of their application. ACS itself doesn’t store credentials or act as an identity provider, but rather, it acts as a middleman that can take a series of input claims (e.g. “Google username”, “Windows logon ID”) and transform them into a single claim (“user ID”) used by your app. It’s a cool way to get your application out of the business of handling unique identity providers or storing credentials.

Let’s walk through the steps to building a simple, secure web app that we can deploy to Iron Foundry.

Step 1 – Create new ASP.NET MVC 4 (internet) application

To get started, I built a new ASP.NET MVC application in Visual Studio 2012.

Once the project was created from the MVC4 template, I simply built it and ran it. You can see the default website and notice that I can register for an account. At this point, what this does is store my credentials in the default membership provider (which is a local database). I don’t want that as my long term solution. I want to let users log in with their web identity provider of choice.

2. Configure Access Control Service to Recognize Our Iron Foundry Application

Virtually every Windows Azure service has migrated from the clunky Silverlight portal to the new, clean HTML portal. Unfortunately, Windows Azure ACS still lives in the old portal. Once I regretfully logged into it, I saw the options to add/configure identity providers, set up the relying party applications (like the one I created), and define the claims transformation rules.

If I wanted to add ADFS as a valid identity provider, I could do that here. Instead, since I used existing web identity providers, I could jump right to the “relying party applications” section. On the first part of this form, I set the friendly name of the application, and the URL that will receive the claims. Initially (until I deployed to Iron Foundry) this was a local address on my machine.

Further down this form, I was asked which (configured) identity providers I wished to use, whether or not to create a new set of claims transformation rules, and what certificate to use for signing the tokens.

After saving my relying party entry, I jumped to the “Rule Groups” section of this portal to configure the transformation rules. I chose the option to “generate rules” for all the available identity providers, and was left with a series of “passthrough” rules that take whatever claim value was issued by the identity provider and ships it, as is, to my application.

An individual one of these rules, such as the “Google name” one, has an input claim type and value, and an output claim type and value. While the one below has the same type and passthrough value, you can imagine how you might have three different providers with different input claim types/values all map to a single, internally-defined claim type and/or value.

3. Configure ASP.NET App to use ACS for Identity Management

With my ACS configuration complete (for now), I returned to Visual Studio 2012 to make it “ACS aware.” Now there is a great new tool for Visual Studio 2012 and the latest Windows Identification Foundation bits (which you can see by grabbing the Identity and Access Tools), but since Iron Foundry doesn’t yet support .NET 4.5, I wasn’t able to use the wizard tooling. The latest WIF only applies to .NET 4.5, so I jumped back to using WIF 3.5. To easily grab this version, simply add the NuGet package for Windows Identification Foundation  to a project.

With all the proper assemblies in place, I then manually updated my web.config file to reflect my use of WIF and ACS. You can find my complete web.config file below. To learn more about the significance of each section, I’d recommend the blog post Windows Identity Foundation (WIF) Configuration Sections in ASP.NET Web.Config.

That’s about it. Clearly if I wanted to customize the handling of these claims (e.g. show the value of a claim besides “name” on the home page), there’s additional work I’d want to do in my code. When I ran this application, I was quickly prompted for credentials and the ACS site served up a page for me to select which identity provider to use.

When I chose the Google provider, I was redirected to the Google accounts page and asked to log in.

Once I logged into my account, I was returned to my custom web app which recognized that I was now authenticated!

To prove that this is an account that wasn’t managed by my application itself, I clicked on my name to “manage” my user. I was presented a message indicating that there’s no local password for this user, as the identity provider was NOT my local membership provider.

4. Update and Deploy the App to Iron Foundry Environment

The final task was to update the ASP.NET application and ACS configurations before deploying the application to Iron Foundry. First, I returned to the Windows Azure ACS portal to change the “realm” of the relying party entry that I created for my custom application. I planned on deploying this application to the free IronFoundry.me environment, so I entered the expected destination of the application.

After saving this change, I returned to my Visual Studio project and entered that same IronFoundry.me URL into the web.config file where the “localhost” value had been before. After publishing the website to the file system and executing a Cloud Foundry vmc push command from my Command console, my app was quickly deployed.

Did it work? I browsed my newly published app on Iron Foundry, and just as with the local site, I was prompted for which identity provider to use. After selecting Google and plugging in my credentials, I saw my logged in user on the website.

Cool! This is a fun case of being able to use the public/private Iron Foundry PaaS but still take advantage of other useful services offered by other PaaS solutions.

Thor

Thor is moving along with implementation of services starting yesterday (Monday). You can view our live Huboard Kanban to see what is currently being worked on. The interface in the last few weeks has gotten a faster, cleaner appearance and stabilized even more around deploying and maintaining your Cloud Foundry based environments.

If you’re an XCode user and familiar with Git, check out the README.md to pull down the latest code and try it out yourself against your own Cloud Foundry Projects – private or public hosted!

Thor .NET for Windows Users

The Windows version of the Thor Client is about to go into beta in the coming weeks. It has an elegant metro style interface and will initially be available for Windows 7.

For the WinRT and Windows 8 versions we’re still determining what the best approach is to development of this version of the UI. We’d love any additional input on the WinRT or Windows 8 Applications or how you see you may use the application on WinRT or Windows 8. Let us know in the Iron Foundry Discussion Group.

vcap-client on Nuget

Recently we released the vcap-client library for client usage against any Cloud Foundry and Iron Foundry Built Environments. So if you’re a use of the .NET Framework, this library has all the functionality wrapped up in a Nuget Package for you.

So if you’re a user of AppFog, CloudFoundry.com, Tier 3 Web Fabric, Stackato or another Cloud Foundry enabled environment and write code against the .NET Framework, this is a great library to try out.

Conversations Around Iron Foundry Library

We’re currently having conversations via the Iron Foundry Discussion Group for implementing background services for .NET. Join the conversation if you’d like to contribute, add your suggestions or have any ideas on how this should be implemented.

• Button, styles, and related materials are in line with OS-X standards for the workflow screen of deploying an application.
• Deployments for node.js, erlang, java, .NET and the other supported applications now works.
• More unit tests added around new key features, especially detection of the language/framework support.
• Easier to navigate workflow wizard for deployment with appropriate drop out points, etc.

As for the next steps, our list of stories is listed on Github. Get involved and we’ll have them knocked out even faster. We’d also love any input on features that are available now or in the future or any code reviews, architecture suggestions, or similar. Just join the discussion group and let’s talk.

Here’s a list of some of the key feature stories coming in our next push:

• Thor User wants to be able to add a service to the available services.
• Thor User wants to view a list of services available for use.
• Thor user wants to be able to view multiple bound services for an application.
• Thor User wants to be able to bind a service to an application.
• Thor user wants to see various X parameters for their running services.
• Thor user wants to be able to view available services for their application(s).

First of all, we added some new services. You can confirm this by using vmc (and don’t forget to upgrade your vmc-IronFoundry gem!) and executing a vmc services command.

You should notice a few things here. First, MongoDB has been upgraded from version 1.8 to 2.0. Also, we’re now running PostgreSQL 9.0. You’ll also find the new Cloud Foundry blob service available here.

As far as application runtimes go, we upgraded a couple of those too. You can see this by executing vmc runtimes against the IronFoundry.ME environment.

See that we are running both Java 6 and 7 now. Also, we’ve upgraded our versions of Node and included support for Node 0.8.2.

Besides upgrading services and runtimes, we also added support for the Cloud Foundry User Account and Authorization Service (UAA). The Cloud Foundry blog has articles that Introduce the UAA, review the high level features of the UAA,  and secure REST web services with the UAA. You’ll also find docs on Github that outline the features and configurations, as well as how to use the UAA APIs. Keep an eye out for an upcoming blog post that shows an example of how you use the UAA service within Iron Foundry.

We hope that you can immediately take advantage of the new capabilities in this free IronFoundry.ME environment.

Presenting the Iron Foundry vcap-client. This library provides all of the capabilities wrapped up in the standard Cloud Foundry vcap-client libraries, except for .NET. Not only did we build out this library to provide a programmatic way for .NET Developers to access and manage Cloud Foundry and Iron Foundry environments, we’ve also provided a Nuget Package for the easiest of access.

With the Iron Foundry Nuget Package it will handle all of your dependencies. We only have two in the package, but it is always nice to have those just handled for you.

If you’d like to contribute, find any issues let us know, or just want to download the project directly check out our Iron Foundry vcap-client Github Repo.

PostgreSQL

PostgreSQL (discussed in this previous Iron Foundry blog post), is a very popular open source database. Developers or database administrators typically use the pgAdmin tool to author and debug queries, perform database backups/restorations, reindex and cleanup (VACUUM) data,  manage server jobs, and much more.

You can download the pgAdmin tool directly, or find it included in the PostgreSQL package itself. For this demonstration, I installed PostgreSQL locally and got the pgAdmin tool along with it. After installing the database software, I opened a command prompt on my Windows machine and targeted my Iron Foundry environment.

After authenticating myself, I issued a vmc command (“vmc services“) to see which application services were available, and which services I had already provisioned.

So far, no application services were provisioned. Let’s change that. I created a new PostgreSQL instance by issuing the vmc command vmc create-service postgresql. Note that I didn’t need to bind it to an application and can simply create a standalone instance that could be used by many Iron Foundry web applications.

Now there was a running instance of PostgreSQL in my environment. At this stage, there was no way for the pgAdmin tool to access this instance. However, thanks to the Cloud Foundry Caldecott technology, I could create a secure tunnel for pgAdmin. The vmc tunnel <instance name> command opens up a port that pgAdmin can use to administer that database server.

I could have chosen to use the psql client which would have let me issue commands right here in the command prompt, but since I wanted to use the full-featured pgAdmin tool, I selected the “none” client. Notice that I got four key pieces of information back: username, password, name and port. Together, these data points will get us logged into our environment.

I opened the pgAdmin tool and could see that the only server currently recognized was the one on my local machine.

I clicked the “Add a connection to a server” and was shown the “New Server Registration” prompt. For the “Name” value, I used the “name” that came back from the tunnel command; for “Host” value I set it to “localhost”; for the “Port” I used “10000″; and for the Username and Password, I used the corresponding values returned by the tunnel command.

Once connected, I could navigate all the database artifacts and browse the standard options for backing up data, querying tables, and creating new tables.

The pgAdmin tool is a very handy and useful way to manage your database artifacts and Iron Foundry makes it easy to use this tool against your application services.

MySQL

MySQL is also a very popular open source database and we want to make sure that database developers and administrators can use familiar tooling even if their application instance sits in a PaaS like Iron Foundry.

The MySQL team has made significant investments in their Workbench tool, and here we’ll see exactly how you hook the Workbench up to an Iron Foundry instance. First, I downloaded the standalone Workbench tool.

Then, I added a new MySQL instance to my Iron Foundry environment by using the vmc create-service mysql command.

Like the PostgreSQL example prior, I created a tunnel so that the MySQL Workbench tool could “see” our Iron Foundry instance. As before, I also chose the “none” client so that I could connect the GUI tool instead of issuing command statements only.

Notice that I got back database credentials (“username”/”password”), a schema instance name (“name”), and a port number.

I was now ready to connect the MySQL Workbench to my database instance. The Workbench has three core functions: SQL development, data modeling, and server administration.

In this example, I created a new pair of tables, and deployed them to the database instance in Iron Foundry. In the Workbench, I clicked the “Create New EER Model” in order to generate a data model. The first thing that I did was right-click the schema name and choose “Edit Schema.” On the subsequent window, I changed the default “mydb” name to the the “name” value returned by the vmc tunnel command.

I then chose to add a new diagram to the model and proceeded to create a pair of new tables, “customer” and “order”, and defined a relationship between them.

With the model complete, I chose the “Forward Engineer” option so that this model could be used to generate the actual tables.

I was then prompted to create an actual connection to the target database, and this is where the tunnel-provided values came into play. I plugged in the username and password, and set the Hostname value to “localhost” and the Default Schema to the tunnel-provided “name” value.

I then kept the remaining default options, including the selection of the two tables to forward engineer, and reviewed the pending SQL Script to be executed. After successfully completing the wizard, I could open an instance of the SQL Editor and browse my schema.

Sure enough my two tables, relationship included, were there.

Summary

While one of the key benefits of a PaaS is managed services, it’s important to have the option to administer these application services using the powerful,  familiar management tools currently available to users. Both PostgreSQL and MySQL have solid management interfaces and we saw here how you can tunnel into these Iron Foundry database instances  and perform standard operations against your service.