SunTone Architecture Methodology
The SunTone AMis a significant guiding element in the development of the N1 Grid architecture. Because this methodology was covered in more depth earlier in this book and because complete references are available in Appendix B, only a quick review is provided here. Again, Dot-Com & Beyond provides the general reference for the description below.
The SunTone Architecture Methodology provides a detailed architectural process by which a truly services-driven, network-accessible, N1 Grid environment can be developed. It requires that system architecture be comprehensively addressed before system design because the architecture establishes the overall structure that must be adhered to by each portion of the subsequent design. The SunTone Architecture Methodology is:
Use case focused
Iterative and incremental
Systemic qualities driven
The SunTone Architecture Methodology is the practical realization of a team-oriented approach to specifying, constructing, and assembling software and hardware components into a working system that meets a well-defined need. This methodology, while not the only architectural guidance available, is certainly focused on the specifics needed to adequately address the real business problems that the N1 Grid solves.
KBDs and CTQs
Meeting a well-defined need is a part of the SunTone Architecture Methodology definition. Properly articulating that need is key to developing the solution that solves the problem. Identifying the key business drivers (KBDs) and critical-to-quality elements (CTQs) of the solution is essential to properly identifying the need. While research-based work developed the KBDs and CTQs of the N1 Grid problem, in an interview with Information Week, Sun Microsystems CEO Scott McNealy summarizes the need in very practical terms:
"We take our cues from our customers. What's important to them is important to us. So our No. 1 priority right now is saving them money. The best way to do that is by reducing complexity. People are just absolutely going nuts with the complexity of the current computing environment. A recent study shows that about 10 percent of IT costs are hardware, 10 percent software, and the rest administration and training. Today, a system administrator can manage between 15 and 30 systems; it should be 500. System utilization is around 15 percent; it should be 80 percent. It takes weeks to deploy a new network service; it should take days or even hours. We need to fix those numbers, and we're working on it." (Information Week, January 2003)
Those key business drivers provide the focus of developing the architecture. Reducing cost and complexity in the data center is the focus that drives the goal of achieving strategic flexibility. The functional architecture shown in FIGURE 2 provides the working system to achieve that goal.
Immediate Return on Investment
An important feature of any robust architecture is flexibility. While numerous KBDs and CTQs can be identified, each individual IT environment has different needs. Those needs must be supported by the architecture in a flexible manner. The architecture presented in Part 2 is discussed in an orderly flow; however, it is not a prescriptive flow. The flexibility generally enables an IT organization to do what it wants when it wants.
With that flexible architecture in place, the question becomes, "With so many choices, where do I begin?" Referring back to the discussions about IT supporting the business, the focus should be on efforts that deliver the most immediate ROI. Utilization can be the issue in one environment, while time to market of new services can be the problem in another. Availability and IT automation are two examples of efforts that can result from the implementation of a flexible N1 Grid architecture. The key to achieving true strategic flexibility is tight alignment with the business. Use that alignment to prioritize overall IT efficiency improvements.
One of the cornerstones of the SunTone AM is that it is use-case focused. Use cases provide the real-world in-depth analysis of the problem that directly supports the efforts to develop the functional requirements. Use cases were defined in Chapter 4 as the functional scenarios that describe the complete flow of an operation from the perspective of an actor. Actors are entities that are external to the system, typically users or other systems. In use-case-driven design and development, every attempt is made to prioritize design and development around the realization of complete, end-to-end use cases. The advantage of this approach is that it keeps the project team focused around continuously delivering functionality directly related to the end product being developed.
A significant number of use cases have been developed in support of N1 Grid. They range from academic use cases developed within Sun to various real-world customer use cases. The use cases that support the N1 Grid are very important, but their specific review is not the focus here. This book does, however, rely heavily on the various use cases developed as direct support in the development of the functional architecture described in the next section.
The SunTone AM has guided the development of the architecture that supports strategic flexibility. In alignment with that methodology, there is clear focus on the key business drivers and use cases have been leveraged extensively. This background leads to the development of the strategic flexibility functional architecture.
FIGURE 2 Strategic Flexibility Functional Architecture
As mentioned, there is a particular flow to the description of the architecture. While still flexible in the ways it can be implemented, the architecture is focused on a building block approach. Each block adds value that can then be increased as additional blocks are added. This building block approach is aligned with the description of layers from the SunTone AM.
The development of the first building block starts in the infrastructure layers of hardware and operating system. The process continues as the focus shifts to the application layers. Again, specific and common components are developed during this phase. Finally, the entire layered stack is addressed as a functional whole.
The building block approach of "common themes with specific variations" is an excellent summary of the functional requirements. That approach will become apparent as the specifics of the strategic flexibility architecture are reviewed in detail. The three specific functional components of the strategic flexibility architecture are:
Data center optimization
Leveraging the compute, network, and storage hardware, infrastructure optimization is delivered through the hierarchical building-block architecture flow of build, virtualize, and provision. This component provides the foundation for strategic flexibility. Infrastructure optimization is the focus of Chapter 8.
Using the same building-block architecture, this component focuses on dramatically improving the efficiency of delivering business services through the automated deployment of application components. This second component of the architecture provides the critical functionality required to tie those business services to the IT infrastructure. Application optimization is the focus of Chapter 9.
Through a focus on delivering strategic flexibility, data center optimization refactors the data center based on business demands. Directly dependent on infrastructure and application optimization for its foundation and efficiency, data center optimization enables truly business-focused IT operations. Chapter 10 explores the evolution of IT roles brought about by this business-flexible computing environment. Data center optimization is the focus of Chapter 10.
Strategic Flexibility was defined as the ability to deliver a service-centric, systemic-quality driven, just-in-time IT infrastructure that maximizes utilization of assets and minimizes cost and effort. This functional architecture (FIGURE 2), delivering the combination of infrastructure, application, and data center optimization, enables strategic flexibility and ultimately the N1 Grid. Although this functional architecture view is central to understanding and ultimately realizing the N1 Grid, it is not the end of the architectural process. The architectural process also includes identifying the technical requirements that provide the bridge to design and implementation. Because these are very specific to an implementation, they are not discussed here.
As stated, the completion of the functional architecture is not the completion of the architecture process as a whole. The architecture descriptions in this book do not provide a detailed view beyond the functional architecture. Given this, it is important to briefly review the required elements to transition from architecture, through design, to implementation. Components of this transitional or applied architecture are presented in this section.
The functional architecture is focused on delivering the combination of infrastructure, application, and data center optimization. This combination leads to the development of a strategically flexible functional architecture. The functional requirements summarize what that architecture looks like. The next step in this process is to identify how the architecture is delivered.
The technical requirements are the most granular requirements defined as part of the architectural process. The technical requirements are detailed specifications that explain exactly how the functional architecture will be realized in a specific implementation. Technical requirements are most often specifications to the individual product level. Due to their specificity, these requirements are unique to each individual IT environment.
The review of the different levels of the functional architecture in the following chapters does not discuss the technical requirements because technical requirements by nature are implementation specific. However, product examples are presented throughout that could be part of the technical requirements of an actual implementation. In the examples that demonstrate the application of a particular functional component, the technical requirements of same as the components.
With the technical requirements and a solid functional architecture as a foundation, design and implementation should flow naturally into the next steps, with the exception of constraints. Basically, anything architecturally significant already in the environment or predefined as being in the environment can be a constraint. For example, if an IT organization has out-sourced the operation of their data center, that would be identified as a constraint. Constraints are static, but they are generally identified as the environment to which the architecture must be integrated.
Constraints come in different forms. To further explain the idea, three categories of constraints are identified and an example of each is given:
Development and team constraints
Environment and technology constraints
Delivery and deployment constraints
Data center system administrators are junior personnel due to recent employee turnover.
The Sun Java™ system server is the IT core standard for J2EE™ deployments.
A third-party consulting company has an outsourcing contract for application support.
Whatever form constraints come in, they must be identified and understood as part of the transition to implementation.
One of the final architectural issues that must be carried into implementation is the idea of iterations. An iterative approach is common in the architecture and development of software. The idea is generally summarized as "make your mistakes early and often." This somewhat humorous view of solving this problem is derived from years of experience delivering complex software architectures. It has been proven that the end-to-end build time can be greatly reduced by iterating the design, build, and test flows. In Chapter 4, the concept of iterations was discussed as a key component of the SunTone AM. That discussion stated that integration testing should occur early, often, and throughout the development cycle, enabling the early detection and correction of requirements, design technology, or usability issues.
Following an iterative approach enables the system to evolve through a series of releases. Each release adds to the overall functionality by building on a solid foundation that has been fully tested. By identifying and addressing issues early, the iterative approach enables a more refined product, delivered with lower risk.
Beginning the Transition
With the architecture process completed, the transition to design and implementation can begin. The danger is that the transition might seem overwhelming. The architecture process can point out many issues and opportunities. There are only a limited number of resources available to solve these issues. With all the options, paths, and limited resources available, what is the best approach? An iterative approach is always best.
The opportunity to deliver real business value through strategic flexibility is real. It is important not to be trapped in "analysis paralysis" or other indecisiveness. There are a lot of options. Focusing on business-based ROI can help to focus efforts. The KBDs, and the entire architecture process they drive, can also focus your efforts.