S90.09試験無料問題集「SOA Design & Architecture Lab 認定」

When Service A receives a message from Service Consumer A(1),the message is
processed by Component A.
This component first invokes Component B (2), which uses values from the message to query Database A in order to retrieve additional data.
Component B then returns the additional data to Component A.
Component A then invokes Component C (3), which interacts with the API of a legacy
system to retrieve a new data value. Component C then returns the data value back to
Component A.
Next, Component A sends some of the data it has accumulated to Component D (4), which
writes the data to a text file that is placed in a specific folder. Component D then waits until
this file is imported into a different system via a regularly scheduled batch import. Upon
completion of the import, Component D returns a success or failure code back to
Component A.
Component A finally sends a response to Service Consumer A (5) containing all of the data
collected so far and Service Consumer A writes all of the data to Database B (6).
Components A, B, C.
and D belong to the Service A service architecture. Database A, the legacy system, and the file folders are shared resources within the IT enterprise.

Service A is a task service that completes an entire business task on its own without having
to compose other services. However, you have received many complaints about the
reliability of Service A . Specifically, it has three problems. First, when Component B
accesses Database A, it may not receive a response for several minutes when the
database is being accessed by other applications in the IT enterprise. Secondly, the legacy
system accessed by Component C frequently crashes and therefore becomes unavailable
for extended periods of time. Third, for Component D to respond to Component A, it must
first wait for the batch import of the files to occur. This can take several minutes during
which Service Consumer A remains stateful and consumes excessive memory. What steps
can be taken to address these three problems?

Services A, B, and C are non-agnostic task services. Service A and Service B use the
same shared state database to defer their state data at runtime.
An assessment of these three services reveals that each contains some agnostic logic, but
because it is bundled together with the non-agnostic logic, the agnostic logic cannot be
made available for reuse.
The assessment also determines that because Service A and Service B and the shared
state database are each located in physically separate environments, the remote
communication required for Service A and Service B to interact with the shared state
database is causing an unreasonable decrease in runtime performance.

How can the application of the Orchestration pattern improve this architecture?

Service A is a task service that is required to carry out a series of updates to a set of
databases in order to complete a task. To perform the database updates Service A must
interact with three other services, each of which provides standardized data access
capabilities.
Service A sends its first update request message to Service B (1), which then responds
with a message containing a success or failure code (2). Service A then sends its second
update request message to Service C (3), which also responds with a message containing
a success or failure code (4). Finally, Service A sends a request message to Service D (5),
which responds with its own message containing a success or failure code (6).

You've been asked to change this service composition architecture in order to fulfill a set of
new requirements: First, if the database update performed by Service B fails, then it must
be logged by Service A.
Secondly, if the database update performed by Service C fails,
then a notification e-mail must be sent out to a human administrator. Third, if the database
update performed by either Service C or Service D fails, then both of these updates must
be reversed so that the respective databases are restored back to their original states.
What steps can be taken to fulfill these requirements?

Service A is a task service that sends Service B a message (2) requesting that Service B
return data back to Service A in a response message (3). Depending on the response
received. Service A may be required to send a message to Service C (4) for which it
requires no response.
Before it contacts Service B, Service A must first retrieve a list of code values from its own
database (1) and then place this data into its own memory. If it turns out that it must send a
message to Service C, then Service A must combine the data it receives from Service B
with the data from the code value list in order to create the message it sends to Service C.
If Service A is not required to invoke Service C, it can complete its task by discarding the
code values.
Service A and Service C reside in Service Inventory A.
Service B resides in Service Inventory B.

You are told that the services in Service Inventory A were designed with service contracts
based on different design standards than the services in Service Inventory B.
As a result,Service A and Service B use different data models to represent the data they need to
exchange. Therefore, Service A and Service B cannot currently communicate.
Furthermore, Service C is an agnostic service that is heavily accessed by many concurrent
service consumers. Service C frequently reaches its usage thresholds during which it is not
available and messages sent to it are not received. How can this service composition
architecture be changed to avoid these problems?