Free Arcitura Education S90.09 Actual Exam Questions

Our service inventory contains the following three services that provide invoice-related data access
capabilities: Invoice, InvProc, and Proclnv. These services were created at different times by different
project teams and were not required to comply to any design standards. Therefore each of these
services has a different data model for representing invoice data. Currently each of these three
services has one service consumer: Service Consumer A accesses the Invoice service(1). Service
Consumer B (2) accesses the InvProc service, and Service Consumer C (3) accesses the Proclnv
service. Each service consumer invokes a data access capability of an invoice-related service,
requiring that service to interact with the shared accounting database that is used by all invoice-
related services (4, 5, 6). Additionally, Service Consumer D was designed to access invoice data from
the shared accounting database directly (7), (Within the context of this architecture. Service
Consumer D is labeled as a service consumer because it is accessing a resource that is related to the
illustrated service architectures.)

Assuming that the Invoice service, InvProc service, and ProcInv service are part of the same service
inventory, what steps would be required to fully apply the Official Endpoint pattern?

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 given a requirement that all database updates must either be completed successfully or
not at all. This means that if any of the three response messages received by Service A contain a
failure code, all of the updates carried out until that point must be reversed. Note that if Service A
does not receive a response message back from Services B, C, or D, it must assume that a failure has
occurred. How can this service composition architecture be changed to fulfill these requirements?

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.

You are asked to redesign this architecture in order to increase the opportunity for agnostic service
logic to be reused and in order to decrease the runtime processing demands so that performance can
be improved. What steps can be taken to achieve these goals?

Service A is a utility service that provides generic data access logic to a database that contains data
that is periodically replicated from a shared database (1). Because the Standardized Service Contract
principle was applied to the design of Service A, its service contract has been fully standardized.
Service A is being accessed by three service consumers. Service Consumer A accesses a component
that is part of the Service A implementation by invoking it directly (2). Service Consumer B invokes
Service A by accessing its service contract (3). Service Consumer C directly accesses the replicated
database that is part of the Service A implementation (4).

You've been told that the reason Service Consumers A and C bypass the published Service A service
contract is because, for security reasons, they are not allowed to access a subset of the operations in
the WSDL definition that expresses the service contract. How can the Service A architecture be
changed to enforce these security restrictions while avoiding negative forms of coupling?

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 are all SOAP-based Web services designed to
exchange SOAP 1.1 messages and the services in Service Inventory B are SOAP-based Web services
designed to exchange SOAP 1.2 messages. Therefore, Service A and Service B cannot currently
communicate. Furthermore, you are told that Service B needs to access a shared database in order to
retrieve the data required by Service A . The response time of the database can sometimes be
lengthy, which would cause Service A to consume too much resources while it is waiting and keeping
the code values in memory. How can this service composition architecture be changed to avoid these
problems?

Service Consumer A invokes Service A (1). The logic within Service A is required to retrieve three
independent data values from Services B, C, and D and to then return these data values back to
Service Consumer A . To accomplish this, Service A begins by sending a request message to Service B
(2). After receiving a response message with the first data value from Service B, Service A sends a
request message to Service C (3). After it receives a response message with the second data value
from Service C, Service A then sends a request message to Service D (4). Upon receiving a response
message with the third data value from Service D . Service A finally sends its own response message
(containing all three collected data values) back to Service Consumer A . Service Consumer A and
Service A reside in Service Inventory A . Service B and Service C reside in Service Inventory B . Service
D is a public service that can be openly accessed via the World Wide Web. The service is also
available for purchase so that it can be deployed independently within IT enterprises. Due to the
rigorous application of the Service Abstraction principle within Service Inventory B, the only
information that is made available about Service B and Service C are the published service contracts.
For Service D, the service contract plus a Service Level Agreement (SLA) are made available. The SLA
indicates that Service D has a planned outage every night from 11 PM to midnight.

You are an architect with a project team building services for Service Inventory A . You are told that
the owners of Service Inventory A and Service Inventory B are not generally cooperative or
communicative. Cross-inventory service composition is tolerated, but not directly supported. As a
result, no SLAs for Service B and Service C are available and you have no knowledge about how
available these services are. Based on the service contracts you can determine that the services in
Service Inventory B use different data models and a different transport protocol than the services in
Service Inventory A . Furthermore, recent testing results have shown that the performance of Service
D is highly unpredictable due to the heavy amount of concurrent access it receives from service
consumers from other organizations. You are also told that there is a concern about how long Service
Consumer A will need to remain stateful while waiting for a response from Service A . What steps can
be taken to solve these problems?

Service A is a utility service that provides generic data access logic to a database that contains data
that is periodically replicated from a shared database (1). Because the Standardized Service Contract
principle was applied to the design of Service A, its service contract has been fully standardized. The
service architecture of Service A is being accessed by three service consumers. Service Consumer A
accesses a component that is part of the Service A implementation by invoking it directly (2). Service
Consumer B invokes Service A by accessing its service contract (3). Service Consumer C directly
accesses the replicated database that is part of the Service A implementation (4). You've been told
that the shared database will soon be replaced with a new database product that will have new data
models and new replication technology. How can the Service A architecture be changed to avoid
negative impacts that may result from the replacement of the database and to establish a service
architecture in which negative forms of coupling can be avoided in the future?

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 state ful and consumes excessive
memory. What steps can be taken to address these three problems?