Its here!
msdn subscribers can download today, general availability is 21st October. Visit the Visual Studio 2010 / .NET Fx 4 Beta site for more information, downloads, forums and to submit feedback.
You’ll also notice that MSDN website has undergone a redesign and MSDN subscribers will also see new benefits such as Azure compute hours, Team Foundation Server and e-learning options.
You can read Soma's blogpost announcing Visual Studio 2010 / .NET Fx 4.
Cross posting from: http://blog.maordavid.com/windows-azure-service-management-api-has-been-released/
The Windows Azure Service Management API has been released to help you manage your deployments, hosted services and storage accounts. This is a REST-based API that uses X509 client certificates for authentication. Users can code against in their toolset of choice to manage their services. Users can upload any valid X509 certificate in .cer format to the Windows Azure developer portal and then use it as a client certificate when making API requests.
Supported operations:
- Deployments – Viewing, creating, deleting, swapping, modifying configuration settings, changing instance counts, and updating the deployment.
- Listing and viewing properties for hosted services, storage accounts and affinity groups.
A tool called csmanage.exe have already uploaded to help you interact with this API and manage your deployments. For an overview of the Management APIs, see Introducing the Windows Azure Service Management API blog posting from the Windows Azure team.
Cross posting from: http://blog.maordavid.com/multi-tenant-architecture-windows-azure-platform/
common question is how a multi-tenant architecture works with Windows Azure Platform. You can find an answer at Project Riviera that has been released on MSDN and includes source code.
From the project page:
Project Riviera is a comprehensive code sample to demostrate how to develop multi-tenant highly-scalable line-of-business application on Windows Azure Platform. This sample is developed by Global Partner Architecture Team in Developer & Platform Evangelism group at Microsoft in collaboration with Cumulux - our Cloud ISV partner. Riviera uses Customer Loyalty Management scenario for illustration purpose but many building blocks are applicable to range of line-of-business applications.
Click here to view a screncast of Riviera, Architecture details and other related information.
Key features of Riviera
- Multi-tenant data store based on Azure Table Storage as well as SQL Azure.
- Per tenant customization of data model
- Per tenant customization of business logic (using Windows Workflow in Windows Azure)
- Per tenant customization of user interface using Silverlight 3.0. Customization can be multi-level – custom theme, custom XAML, and custom XAP.
- Automated tenant provisioning
- Windows Azure web role->Azure Queue->worker role pattern for high volume transaction processing that can scale on demand
- Claims aware web service and web application using Geneva Framework
- Active and Passive Federation using Geneva Framework, Geneva Server and .NET Access Control Service (ACS)
- Windows Live ID authentication for consumer facing web site
- Use of Patterns & Practices Enterprise Library Caching and Logging application blocks in Windows Azure
Notes - Project Riviera is not a product or solution from Microsoft. It is a comprehensive sample code developed for evangelism purpose.
- Riviera includes implementation of Security Token Service (STS) using Geneva Framework in Windows Azure. We would like to emphasize that this scenario is currently not supported (at the time of July 2009 CTP). This is primarily because of lack of certificate store support in Windows Azure at this time. So although the implementation works in Windows Azure, we advise not to do so for production environment untill such scenario can be supported on Windows Azure and product group provides guidance to do so.
Posted at: http://blog.maordavid.com/2009/06/wcf-load-test/
Just published on CodePlex -WCF Load Test tool.
Project Description from the project home page on CodePlex:
This tool takes a WCF trace file and a WCF client proxy, or a WCF interface contract, and generates a unit test that replays the same sequence of calls found in the trace file. The code generated is easily modifiable so that data variation can be introduced for the purpose of doing performance testing.
The tool generates code for both Visual Studio 2005 and Visual Studio 2008. It also installs a wizard into both editions of Visual Studio for creating the trace and processing it from inside Visual Studio. If both editions are present the tool is installed into both editions. The source code is a Visual Studio 2005 project.
Latest Release June 2009
A new beta was released in June 2009 adding support for ASMX web services. Download it from here. Features
The tool has the following main features: - Replay of captured scenario in a unit test that can be included in a load test.
- Support for the DataContractSerializer.
- Support for message contracts.
- ASMX support (beta)
- Support for proxies generated using svcutil.
- Support for clients that create proxies at run time from contract interfaces.
- Supports calls to multiple services in a single scenario.
- Supports multiple calls to the same service operation.
- Filtering by SOAP action of which messages in the trace to replay.
- Readable and modifiable code is generated.
- Automatic association of trace message with proxy method (requires all operations to have a unique SOAP action).
- Support for client and server side traces.
- A command line tool for processing traces and generating code.
- Visual Studio 2005/2008 integration (Team Developer, Team Test, Team Suite and for 2008 also Professional)) that can be used instead of the command line tool.
The DebuggerDisplay attribute (System.Diagnostics.DebuggerDisplayAttribute) controls how a class or field is displayed in the debugger variable windows. When a custom object is displayed, the name of the class or the result of ToString() is shown. This can be changed with a DebuggerDisplay attribute....
Read full article
Originally posted at: http://blog.maordavid.com/2009/05/new-version-of-windows-azure-tools-for-microsoft-visual-studio/
Windows Azure Tools for Microsoft Visual Studio extend Visual Studio 2008 and Visual Studio 2010 Beta 1 to enable the creation, building, debugging, running and packaging of 
scalable web applications and services on Windows Azure. Installation includes the Windows Azure SDK.
New for the May 2009 CTP:
- Support for Visual Studio 2010 Beta 1
- Update for Visual Studio 2008
- Improved integration with the Development Fabric and Storage services to improve the reliability of debug and run of Cloud Services from Visual Studio
- Enhanced robustness and stability
Windows Azure Tools for Microsoft Visual Studio includes:
- C# and VB Project Templates for building Cloud Services
- Tools to change the Service Role configuration
- Integrated local development via the Development Fabric and Development Storage services
- Debugging Cloud Service Roles running in the Development Fabric
- Building and packaging of Cloud Service Packages
- Browsing to the Azure Services Developer Portal
- SSL Certificate selection
Download here
In this post I’ll demonstrate how to use the Microsoft .NET Services Service Bus and the 
NetTcpRelayBinding. The post based on the Echo sample in Azure SDK for .NET Services (March 2009 CTP).
What is a .NET Service Bus? it provides a relay service that makes it possible to establish connectivity through the cloud across organizational boundaries. This crucial infrastructure allows cloud-based workflows to communicate with on-premise applications by traversing firewalls and NAT devices.
The sample shows a simple service and client that communicate through the Service Bus. When the service application is started, it asks for your .NET Services Solution Credentials and opens an endpoint on the Service Bus. Once opened, this endpoint has a well-known URI on the Service Bus and is, irrespective of whether your machine is residing behind a Firewall or Network Address Translation, reachable from anywhere.
Configuring the Service
You configure the .NET Access Control Service through the administration portal provided within a particular solution. This is where you configure the rules that determine how it will issue claims for the users it knows about or as a result of transforming claims from other providers.
When using the .NET Service Bus, you'll configure endpoints that use this Service Bus scope as the base URI (yours will be customized to your account, of course). Every solution comes preconfigured with a set of access control rules for both the .NET Service Bus and the .NET Workflow Service.
The Contract
Our service implements very simple contract that works as a Twitter wrapper. Currently there is only one method – CheckIfUserFollowMe that checks if a user follows you. (You can download the code and add other operations to the contract).
[ServiceContract(Name = "ITwitterContract", Namespace = "http://samples.maordavid.com/ServiceModel/Relay/")]
public interface ITwitterContract
{
[OperationContract]
bool CheckIfUserFollowMe(string user,string password,string friendScreenName);
}
public interface ITwitterChannel : ITwitterContract, IClientChannel { }
The Service
The service configuration file:
<configuration>
<system.serviceModel>
<services>
<!-- Application Service -->
<service name="Blog.MaorDavid.Samples.TwitterService">
<endpoint contract="Blog.MaorDavid.Samples.ITwitterContract"
binding="netTcpRelayBinding" />
</service>
</services>
</system.serviceModel>
</configuration>
The configuration file is just like any other WCF configuration file with the exception that configured service endpoint refers a "netTcpRelayBinding", which isn't part of the .NET Framework. The NetTcpRelayBinding is one of the new bindings introduced with the Service Bus.
In order to hook a listening service into the Service Bus, the Service Bus service needs to be able to verify that the owner of the listening service is authorized to do so.
Authentication and authorization are both performed by the Microsoft .NET Services Access Control Service. In order to make these steps simple, the Microsoft.ServiceBus Framework contains a set of transport client credential helpers that automatically deal acquiring required security tokens.
Console.Write("Your Solution Name: ");
string solutionName = Console.ReadLine();
Console.Write("Your Solution Password: ");
string solutionPassword = MicrosoftSDKUtilities.ReadPassword();
// create the endpoint address in the solution's namespace
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", solutionName, "TwitterService");
// create the credentials object for the endpoint
TransportClientEndpointBehavior userNamePasswordServiceBusCredential = new TransportClientEndpointBehavior();
userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;
userNamePasswordServiceBusCredential.Credentials.UserName.UserName = solutionName;
userNamePasswordServiceBusCredential.Credentials.UserName.Password = solutionPassword;
The credential used in this example is a simple Username/Password credential that is backed by the Solution credentials you set up when signing up for Microsoft .NET Services. Each Microsoft .NET Services solution automatically owns a branch of the Service Bus global namespace. "Your" Solution namespace branch is rooted at
[scheme]://solution-name.servicebus.windows.net/
whereby [scheme] is either "sb" (as in this example) or "http" or "https". The namespace owner can subdivide that namespace and organize services onto that namespace as needed and define rules in the Access Control Service to guard access to branches of the namespace.
When I run the host application, the WCF hosting infrastructure automatically authenticates with the .NET Access Control Service, acquires claims, and then opens an outbound port to the .NET Service Bus and registers a listener on the specified address. At that point, the locally hosted service will be ready to receive messages relayed through the .NET Service Bus on the specified address. I can also browse to the base address of the solution at this point to access the service registry feed and any active listener endpoints will appear in the feed.
The Client
The client configuration file will need to look just like the host configuration file. Only the endpoint definition will need to appear within the <client> section.
<configuration>
<system.serviceModel>
<client>
<!-- Application Endpoint -->
<endpoint name="RelayEndpoint"
contract="Blog.MaorDavid.Samples.ITwitterContract"
binding="netTcpRelayBinding"/>
</client>
</system.serviceModel>
</configuration>
When started, it asks for the Solution credentials, creates a channel to the Service and sends requests to the service.
Console.Write("Your Solution Name: ");
string solutionName = Console.ReadLine();
Console.Write("Your Solution Password: ");
string solutionPassword = MicrosoftSDKUtilities.ReadPassword();
// create the service URI based on the solution name
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", solutionName, "TwitterService");
// create the credentials object for the endpoint
TransportClientEndpointBehavior userNamePasswordServiceBusCredential = new TransportClientEndpointBehavior();
userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;
userNamePasswordServiceBusCredential.Credentials.UserName.UserName = solutionName;
userNamePasswordServiceBusCredential.Credentials.UserName.Password = solutionPassword;
// create the channel factory loading the configuration
ChannelFactory<ITwitterChannel> channelFactory = new ChannelFactory<ITwitterChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
// apply the Service Bus credentials
channelFactory.Endpoint.Behaviors.Add(userNamePasswordServiceBusCredential);
// create and open the client channel
ITwitterChannel channel = channelFactory.CreateChannel();
channel.Open();
You can download the sample:
And this is what we get:
Enjoy!
Last week we launched the Windows Web Application Gallery, a catalog of the most popular Web applications that ALL run on Windows. 
The Windows Web Application Gallery is a community hub of free and popular .NET and PHP applications for you to use for creating dynamic web solutions.
Features include:
- Simple install of the application through the Web Platform Installer
- Rate and Comment on Applications
- Sort by Most Popular, Highest Rated, Latest
- Filter by Category
- Submit your own Web Applications
- Strategic part of increasing our NextWeb goals around server share
The Microsoft Web Platform is our vision to deliver the best platform to developers for building their Web applications. Microsoft is committed to delivering the platform, tools, and applications that development organizations, communities, and developers need and value; with the long-term idea of supporting a lucrative market to benefit developers and end-users. The Microsoft Platform is designed to interoperate with both ASP.NET and PHP, and integrate easily with community applications and products in the market today.
ASP.NET MVC 1.0 RTW (Release To Web) is now officially released. You can download it right now here. Also check out Phil Haack’s post on the release.
MSDN Documentation for MVC is also now available at the following link http://go.microsoft.com/fwlink/?LinkId=145989
Silverlight 3 Beta was unveiled at MIX09. 
It is a preview release which continues Silverlight’s track record of rapid innovation - introducing more than 50 new features, including support for running Silverlight applications out of the browser, dramatic video performance and quality improvements, and features that radically improve developer productivity.
To get started, you’ll first want to download the tools to make Silverlight 3 Beta development productive for you.
- Silverlight 3 Beta Tools for Visual Studio – this will install the developer runtime of Silverlight 3 Beta, the Visual Studio project templates and the Silverlight 3 Beta SDK.
- Silverlight 3 Beta developer runtimes: Windows or Mac. If you installed the tools above, you will get the developer runtime and there is no need to install it again. These downloads are being made available for test machines for the Windows and Mac platforms for your applications.
- Microsoft Expression Blend 3 Preview – this is the preview version of Expression Blend that will enable authoring of Silverlight 3 Beta applications.
- Silverlight Toolkit – the toolkit has been updated to provide an updated to Silverlight 2 controls, a new release for Silverlight 3 Beta controls, and a new themes gallery. All of these can be downloaded at the Silverlight Toolkit CodePlex project site.
- .NET RIA Services – Microsoft .NET RIA Services simplifies the traditional n-tier application pattern by bringing together the ASP.NET and Silverlight platforms. The RIA Services provides a pattern to write application logic that runs on the mid-tier and controls access to data for queries, changes and custom operations.
- Silverlight 3 Beta Documentation – to view the Silverlight 3 Beta documentation you can view it online or download an offline CHM help file.
New project on Codeplex - Team Foundation Adapters implements Interfaces and Adapters for the TFS API objects. Being able to mock dependencies is a core tenet of unit testing is important. This project allows us to create robust Unit Tests for apps that extend the TFS system.
Quest Software has announced that they will be creating an Oracle DSP (Database Schema Provider) for Visual Studio Team System 2010. This means that all if you have Oracle databases in your apps you can get the same benefits from the Database Edition.
Quest has opened up a Beta program on their TeamFuze.net site for Oracle professionals using Team System.
In my previous post I explained how to deploy Windows Azure to the cloud. Many readers asked me for the the code of the application. You can download it here:
Enjoy!
In this post I’ll explain the steps required to host a cloud service in the cloud…
Step 1: Creating the project on Azure Services Developer Portal
In order to host the asp.net cloud application I created in the previous post, I should login into Windows Azure Services Developer Portal. Because I created cloud service, I have to choose a new Hosted Service Project.
I’ll give a label and description to the service:
And give it a name…
Finally, we have a project.
Note: the Application ID will be needed in order to package and publish the application from Visual Studio.
Step 2: Deploying from Visual Studio to the Cloud
In Visual Studio we have to open the properties window of the cloud service. There is a tab called Portal.
To make sure the correct web page on the Azure portal is opened, we should paste the Application ID from the previous step.
Now, we can publish it to the cloud!
Choosing the Publish action opens up the folder in which the application has been packaged and opens up the browser with the application properties page.
Selecting the Deploy button will open the Deployment page – there we can locate both the package file (.cspkg) and the configuration settings file (.cscfg).
After clicking Deploy – the application deployed to the cloud and initialized.
Now we can test it on a staging environment by clicking the Web Site URL. When the application is ready to be published to production just press the switch icon to move from staging to production.
You can navigate to the cloud app: http://maorsblog.cloudapp.net/Default.aspx
Enjoy!
The Azure™ Services Platform (Azure) is an internet-scale cloud services platform hosted in Microsoft data centers, which provides an operating system and a set of developer services that can be used individually or together. Azure’s flexible and interoperable platform can be used to build new applications to run from the cloud or enhance existing applications with cloud-based capabilities. Its open architecture gives developers the choice to build web applications, applications running on connected devices, PCs, servers, or hybrid solutions offering the best of online and on-premises.
In this post we will create simple web site and execute it in the local development fabric. The Development Fabric simulates the Windows Azure fabric on your local machine so that you may run and test your service locally before deploying it.
Learn how to initialize the development fabric here.
Pre-requisites for this post:
Windows Vista SP1 / Windows Server 2008 IIS 7 with ASP.NET Microsoft Visual Studio 2008 Microsoft .NET Framework 3.5 SP1 Windows Azure SDK 1.0.0 Windows Azure Tools for Microsoft Visual Studio 1.0 Note, you can use the Microsoft Web Platform Installer to get all the prerequisites.
Creating the project
After installation of the SDK and VS tools, new project templates are available in Visual Studio.
You will use the Windows Azure Tools for Microsoft Visual Studio to create the project using the Cloud Service project templates. These tools extend Visual Studio 2008 to enable the creation, building and running of Windows Azure services.
For a Hosted Windows Azure project you have the possibility to create a Web Cloud Service or a Worker Cloud Service. A single project may contain one of each but no more.
For now I’m going to create a Web Cloud Service which is an ASP.NET Forms application.
The MyFirstAzureService_WebRole project is a standard ASP.NET Web Application project template that has been modified to work with Windows Azure. This contains the bulk of the project.
The MyFirstAzureService project contains a reference to the ASP.NET project, along with ServiceDefinition.csdef and ServiceConfiguration.cscfg files. The ServiceDefinition.csdef file contains the metadata needed by the Windows Azure fabric to understand the requirements of your application, such as which roles are used. It will also contain configuration settings that apply to all instances. These configuration settings can be read using the Windows Azure API. The ServiceConfiguration.cscfg file lets you set the values for the configuration settings and the number of instances to run for each role.
The Roles node in the Cloud Services project enables you to configure what roles the services include (Web, worker or both) as well as which projects are used for these roles.
Adding configuring roles through the Roles node will update the ServiceDefinition.csdef and ServiceConfiguration.cscfg files.
Lets modify the default.aspx page, then build and execute the site in the development fabric.
To show the development fabric UI, right-click its icon in the system tray and select Show Development Fabric UI.
Windows Azure development fabric
Expand the tree on the left panel to see the WebRole instances. Click on the node with the 0 label. This shows the log for this instance. Also, we can see here that my Web Role is started.
That's all! Now that our website is running locally we can go and publish this to the cloud (if we registered to Windows Azure) or explore some of the Windows Azure API and development fabric features as Configuration, Logging, and Debugging – This will be in the next post.
Enjoy!
