Figure ‘Architecture of SOA’ shows a complete view of a SOA. Please note this architecture diagram is not tied up with implementation of Microsoft, IBM etc. It’s a general architecture. Any vendor who implements SOA needs to fulfill the below SOA components. How they do it is completely their own technological implementation.
Figure: - Architecture of SOA
The main goal of SOA is to connect disparate systems. In order that these disparate system work they should messages to each other. ESB (Enterprise service bus) acts like a reliable post office which guarantees delivery of messages between systems in a loosely coupled manner. ESB is a special layer which delivers messages between applications. In the figure we have shown a huge plump pipe. It’s not hardware or some wire etc. It’s a group of components/software which helps you to send and receive messages between the disparate applications. Do not try to code your own ESB, you can think of buying one from Microsoft, IBM, Oracle, progress etc.
SOA registry is like a reference database of services. It describes what each services do, where are they located and how can they communicate. It’s a central reference of meta-data for services.
SOA workflow allows us to define work flow using the services in SOA registry. We will read more about BPM in the further questions.
Service broker reads the work flow and takes services from the SOA registry and ties them together. Service brokers are normally middleware like EAI (Enterprise application Integration) products. You can get a list of decent EAI from Sun, Microsoft, and IBM etc.
Process manager is nothing but the collection of SOA registry, SOA workflow and service broker.
SOA supervisor is traffic cop ensuring that services do not have issues. It deals mainly with performance issues of the system so that appropriate service levels are met. If any of the services have performance problems it sends messages to the proper infrastructure to fix the issue.
Key
Components of SOA
The first step in learning something
new is to understand its vocabulary. In the context of SOA, we have the terms service,
message, dynamic discovery, and web services. Each of
these plays an essential role in SOA.
Service
A service in SOA is an exposed piece
of functionality with three properties:
- The interface contract to the service is platform-independent.
- The service can be dynamically located and invoked.
- The service is self-contained. That is, the service maintains its own state.
A platform-independent interface
contract implies that a client from anywhere, on any OS, and in any language,
can consume the service. Dynamic discovery hints that a discovery service
(e.g., a directory service) is available. The directory service enables a
look-up mechanism where consumers can go to find a service based on some
criteria. For example, if I was looking for a credit-card authorization
service, I might query the directory service to find a list of service
providers that could authorize a credit card for a fee. Based on the fee, I
would select a service (see Figure 1.1). The last property of a service is that
the service be self-contained.
|
Figure
1.1. Directory service
|
Message
Service providers and consumers
communicate via messages. Services expose an interface contract. This contract
defines the behavior of the service and the messages they accept and return.
Because the interface contract is platform- and language-independent, the
technology used to define messages must also be agnostic to any specific
platform/language. Therefore, messages are typically constructed using XML
documents that conform to XML schema. XML provides all of the functionality,
granularity, and scalability required by messages. That is, for consumers and
providers to effectively communicate, they need a non-restrictive type of
system to clearly define messages; XML provides this. Because consumers and
providers communicate via messages, the structure and design of messages should
not be taken lightly. Messages need to be implemented using a technology that
supports the scalability requirements of services. Having to redesign messages
will break the interface to providers, which can prove to be costly.
Dynamic
Discovery
Dynamic discovery is an important
piece of SOA. At a high level, SOA is composed of three core pieces: service
providers, service consumers, and the directory service. The role of providers
and consumers are apparent, but the role of the directory service needs some
explanation. The directory service is an intermediary between providers and
consumers. Providers register with the directory service and consumers query
the directory service to find service providers. Most directory services
typically organize services based on criteria and categorize them. Consumers can
then use the directory services' search capabilities to find providers.
Embedding a directory service within SOA accomplishes the following:
- Scalability of services; you can add services incrementally.
- Decouples consumers from providers.
- Allows for hot updates of services.
- Provides a look-up service for consumers.
- Allows consumers to choose between providers at runtime rather than hard-coding a single provider.
Web
Service
Although the concepts behind SOA
were established long before web services came along, web services play a major
role in a SOA. This is because web services are built on top of well-known and
platform-independent protocols. These protocols include HTTP, XML, UDDI, WSDL,
and SOAP. It is the combination of these protocols that make web services so
attractive. Moreover, it is these protocols that fulfill the key requirements
of a SOA. That is, a SOA requires that a service be dynamically discoverable
and invokeable. This requirement is fulfilled by UDDI, WSDL, and SOAP. SOA
requires that a service have a platform-independent interface contract. This
requirement is fulfilled by XML. SOA stresses interoperability. This
requirement is fulfilled by HTTP. This is why web services lie at the heart of
SOA.
Endpoint Architecture
Contract, Address and Bindings on which SOA service stands. Every service
must expose one or more ends by which the service can be available to the
client. End consists of three important things where, what and how:-• Contract (What)
Contract is an agreement between two or more parties. It defines the protocol how client should communicate with your service. Technically, it describes parameters and return values for a method.
• Address (Where)
An Address indicates where we can find this service. Address is a URL, which points to the location of the service.
• Binding (How)
Bindings determine how this end can be accessed. It determines how communications is done. For instance, you expose your service, which can be accessed using SOAP over HTTP or BINARY over TCP. So for each of these communications medium two bindings will be created.
Below figure, show the three main components of end. You can see the stock ticker is the service class, which has an end hosted on www.soa.com with HTTP and TCP binding support and using Stock Ticker interface type.
Figure: - Endpoint
Architecture
Note: - You can also remember the end point by ABC where A stands for Address, B for bindings and C for Contract.
No comments:
Post a Comment