Tuesday, January 26, 2010

DevX coverage of CEA, XML, and SCA Feature Packs

Here is a good DevX article that covers the values of the three WebSphere Application Server Version 7.0 Feature Packs - Communication Enabled Applications (CEA), XML (XQuery, XSLT 2.0, XPath 2.0) Applications, and Service Component Architecture (SCA). It also covers why our strategy of feature packs helps our customers save money, get functions easier, and have more stable environments.

Friday, January 22, 2010

The WebSphere CloudBurst Appliance

Up to this point, we haven't discussed the WebSphere CloudBurst Appliance too much on this blog (though I've been writing about it extensively here). So if you have been following and reading along here and have only casually heard of this new appliance, you may be asking yourself "What is it?" and "What does it do?" Given that, I thought it was about time we provided a brief overview of WebSphere CloudBurst on the WebSphere Community Blog.

Very simply put, WebSphere CloudBurst is a cloud management device provided in an appliance form factor. It provides you with the capabilities to create, deploy, and manage virtualized WebSphere application environments in an on-premise cloud. Laying the foundation for the cloud-based application environment lifecycle capability provided by WebSphere CloudBurst are special virtual images. These virtual images, which are provided and maintained by IBM, provide pre-installed, pre-configured software stacks that include everything from the operating system all the way through the IBM Software middleware tier. As of right now there are three different IBM Software offerings packaged in this virtual image format: WebSphere Application Server (generally available in 6.1 and 7.0 versions), WebSphere Portal 6.1.5 (Beta version), and DB2 Enterprise 9.7 (trial).

Why did I refer to the virtual images as building blocks? Because from these virtual images WebSphere CloudBurst patterns are built. A pattern is a complete representation of your middleware application environment. The appliance comes pre-loaded with a set of best-practice patterns, and you can also build your own. A custom pattern will include the topology (i.e. the number of application server nodes, management nodes, databases, etc.) you desire, as well as your custom configuration like your applications that run in the environment. As an example, here’s a screenshot of a WebSphere Application Server pattern I built using WebSphere CloudBurst:

Once you build your custom application environment in the form of a WebSphere CloudBurst pattern, you can use the appliance to dispense it to your on-premise cloud. This cloud, consisting of a pool of hypervisors (both VMware and PowerVM platforms are supported) and associated compute resources like memory, storage, CPU, and IP addresses, is defined to and managed by the appliance. When deploying your patterns into the cloud, WebSphere CloudBurst uses an intelligent placement algorithm that considers things like available compute resource and high availability to ensure that your application environment runs as safely and efficiently as possible.

The end result of deployment is a fully functional WebSphere middleware environment running in one or more virtual machines. These environments offer the same capabilities and function as if you had deployed them in a more traditional manner, so you can run the same applications you use now unchanged. In addition, you can use WebSphere CloudBurst to apply fixes and upgrades to your application environments in a simple, fast and safe manner, and you can easily remove an environment when you are no longer using it thus returning resources to your cloud.

In my opinion, this is one of those things that is easier to understand when seen. In that regard, I’ve put together quite a few short demonstrations that highlight different features and capabilities of the appliance. If you are interested in reading more, I mentioned a blog earlier, and we have quite a few articles available on developerWorks.

Jerry's 2010 WebSphere Trends

Just in case you missed it, our WebSphere CTO, Jerry Cuomo, has released his top trends for 2010. Read more to learn about our trends towards Agile Delivery and Development, Business Driven IT, and Extreme Transaction Optimization and listen to the video to find out more information on the effects to the WebSphere platform.

Service Component Architecture

It's been way too long for an update on SCA in WebSphere, but wanted to let you know that not only did we release our 1.0.1 refresh of the SCA Feature Pack for WebSphere V7, but our team has also been creating collateral to support developers get started with Open SCA. The feature pack is available for V7 deployments here. I've blogged several times about the features that were added, so you can look at earlier posts in this blog for a good summary if you so desire.

The WebSphere team has been busy at developerworks refreshing and adding articles regarding Open SCA -- Exploring the WebSphere Application Server Feature Pack for SCA:
  1. Part 1: An overview of the Service Component Architecture feature pack
  2. Part 2: Web services policy sets
  3. Part 3: Intents and policies available in the SCA feature pack
  4. Part 4: SCA Java annotations and component implementation
  5. Part 5: Protocol bindings for Service Component Architecture services
  6. Part 6: Using Spring with Service Component Architecture
  7. Part 7: Using Atom and JSON-RPC for Web 2.0 support

IBM Education Assistant has also been enriched with SCA collateral and you can get started here. If you never have seen Education Assistant before, you're missing out on a great resource!

We welcome your comments about the papers themselves, collateral, or the feature pack itself.

Steve Kinder

Monday, January 18, 2010

WebSphere Application Server Administration Using Jython

I recently had the opportunity to review the recently published WebSphere Application Server Administration Using Jython from IBM Press and thought I would share my opinions on this book. In the spirit of full disclosure, I was provided a copy of the book to review at no cost to myself.

After spending a considerable amount of time teaching myself Jython and learning to administer WebSphere Application Server using it, I wish I had a copy of this book when I first started writing Jython scripts for WebSphere Application Server administration. The authors do a great job of both introducing the reader to the Jython language as well as introducing the reader to the WebSphere Application Server administrative objects.

The WebSphere Application Server Administration Using Jython book is brilliantly structured, first the Jython language followed by WebSphere Application Server administration. The book is also full of practical examples.

An excellent resource for both novice and experienced WebSphere Application Server administrator, this book has earned itself a spot on my bookshelf and in my list of my recommended books for folks interested in automating their WebSphere Application Server administration.

Jerry Cuomo's 2010 WebSphere Trends

Jerry (our WebSphere CTO and IBM Fellow) has posted his 2010 trends and focus areas video. Besides these year kick-off videos being entertaining (mildly :) ), they are valuable to understand what we're focusing on across the entire WebSphere set of products.

Check it out here.

Friday, January 8, 2010

External Coverage of XML Feature Pack

Last year InfoQ did a nice article on the XML Feature Pack. The article does a good job of talking to application scenarios where the new XPath 2.0, XSLT 2.0, and XQuery 1.0 standards are valuable. It also talks about why native XML programming is better for performance, multi-core, and cloud strategically as compared to object oriented imperative approaches. The article also mentions comparisons to other technologies.

Today, Dustin Amrheim, wrote an article that focused on the declarative vs. imperative comments in the InfoQ article and talked about how this matters in the cloud. He argues that this is an interesting approach as compared to packaging existing imperative programming models.

Both are worth a read.

WebSphere first on SPECjEnterprise2010 Java EE Benchmark

In case you missed it, we published the first two results for a new benchmark - SPECjEnterprise 2010.

This new benchmark covers the Java EE 5.0 programming model running on an application server. You may remember SPECjAppServer 2004 and our work to lead in that benchmark. Given how old the 2004 benchmark is, it no longer represents the common practices of coding of new applications. This third version of Java enterprise application server benchmark covers areas such as the simplified Java EE 5.0 programming model for persistence and web programming, web services, and messaging.

By being first to publish, IBM continues to demonstrate its commitment to driving standard third-party trusted benchmarking. Also, we show how the WebSphere Application Server really shines on Java EE support in terms of being consistently first to market with highly performant programming models that matter to you. We published both on a simple single server (1) as well as a highly available, scalable cluster configuration (2) which demonstrates WebSphere Application Server 7.0's ability to scale from simple to complex application environments.

If you want to chat about this benchmark, IBM's results, or see some other standardized performance work we're doing at SPEC and can be in the San Jose area at the end of the month, please stop by the "First Joint WOSP/SIPEW International
Conference on Performance Engineering
". I'll be in attendance talking about the SPEC SOA benchmark work.

(1)IBM SPECjEnterprise2010 result of 7903.16 EjOPS using WebSphere Application Server V7 on IBM BladeCenter HS22 (8 nodes, 64 cores, 16 chips) and DB2 9.7 on IBM System x3850 (1 node, 24 cores, 4 chips).
(2)IBM SPECjEnterprise2010 result of 1,013.40 EjOPS using WebSphere Application Server V7 on IBM System x3650 (1 node, 8 cores, 2 chips) and DB2 9.7 on IBM System x3850 (1 node, 12 cores, 2 chips).
Source: http://www.spec.org; Results current as of 01/08/10.

Monday, January 4, 2010

Using the versionInfo and historyInfo commands

If you are an administrator of the WebSphere Application Server product, or if you use it frequently during the course of your job, chances are you are familiar with the versionInfo command. In short, you can run this command to get information about the installed version of the server product. The output is similar to the following:

Report at date and time January 4, 2010 12:04:52 PM CST

Product Directory C:\was70\as
Version Directory C:\was70\as\properties\version
DTD Directory C:\was70\as\properties\version\dtd
Log Directory C:\was70\as\logs
Backup Directory C:\was70\as\properties\version\nif\backup
TMP Directory C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp

Product List
CEA installed
ND installed

Installed Product
Name CEA Feature Pack
Build Level a0944.10
Build Date 11/6/09
Architecture Intel (32 bit)

Installed Product
Name IBM WebSphere Application Server - ND
Build Level cf070942.55
Build Date 10/24/09
Architecture Intel (32 bit)
End Installation Status Report

From the above, I can tell that I have the WebSphere Application Server ND product installed along with the WebSphere CEA Feature Pack.

That's handy in a lot of situations, but what if I want more detail. In particular, what if I want to know about maintenance packages that I have applied to this install? The versionInfo command can provide me this information if I run it with certain options (thanks Johannes, see the comments below), but there is also another command that will give you this information: historyInfo.

The historyInfo command examines the WebSphere Application Server configuration and provides a list of changed components and uninstalled/installed maintenance packages. Here's a small snippet of output from the command:

Installation Event
Maintenance Package ID
Action install
Package Filename
Backup File Name C:\was70\as\properties\version\nif\backup\
Timestamp 2010-01-04 07:57:46-0600
Result success

Component Installation Event
Maintenance Package ID
Component Name was.rt.bundle
Action install
Update Action replace
Timestamp 2010-01-04 07:57:46-0600
Result success

As you can see above, output from the historyInfo command shows me information about an interim fix that was applied, and it shows me the components, in this case the was.rt.bundle component, that were changed as the result of the fix application. Though you can get this same level of detail with certain flavors of the versionInfo command, I thought I'd point out another option as well. For more information about using the historyInfo command check out this entry in the WAS information center.