IBM C1000-174 IBM WebSphere Application Server Network Deployment v9.0.5 Exam Practice Test

Application migration reports in the administrative console classify each finding by severity, and the categories are shown with distinct icons on the enterprise application collection page. Severe issues identify APIs that are unavailable on the target runtime, or behavioural changes that can break the application. Warning issues identify behavioural changes that might break the application and that deserve evaluation. Recommendations are informational findings: they cover deprecated APIs or minor behavioural changes that do not affect most applications. Option C is therefore correct.

Option A, Fatal, is not a category used by the migration report, so it can be dismissed on terminology alone. Option B, Severe, is the opposite end of the scale and is reserved for items that must be resolved before the application can run correctly on the target. Option D, Warnings, applies to changes that could break an application depending on how it uses the affected behaviour; those findings call for review rather than being merely advisory.

In practice, a reviewer should work through Severe items first, assess each Warning against actual application usage, and treat Recommendations as optional clean-up that reduces future migration effort. Recommendations alone should not block a move to the target environment, which is why they are labelled informational rather than as a defect.

A node in WebSphere Application Server is a logical grouping of server processes that share a configuration and a host system. A cell can contain two kinds. Managed nodes have a node agent and are federated into the cell, so the deployment manager can administer them and synchronise their configuration. Unmanaged nodes have no node agent; they are used to represent resources that the cell must know about but cannot fully administer, such as a web server. A cell can therefore hold both managed and unmanaged nodes, which is option D.

The other statements are incorrect. Node agents do not need manual creation after federation, option A, since the addNode command creates and starts the node agent as part of federating the node. Application servers do not have to be on managed nodes, option B, because a stand-alone application server is a valid configuration, though it lacks central administration. Option C, that nodes can span a single or multiple virtual machines, conflicts with the definition of a node as associated with one host; a physical or virtual machine may host several nodes, but a single node does not extend across machines.

When planning topology, administrators generally place one node per machine for each profile, and add an unmanaged node when a web server must be included in the cell so that the plug-in configuration can be generated and propagated.

A class loader policy in WebSphere Application Server controls how many application class loaders are created for the applications on a server. The product recognises two values, Multiple and Single, so options A and C are correct. With the Multiple policy, each application receives its own class loader, which isolates applications from one another and allows each to carry its own versions of libraries without conflict. With the Single policy, one class loader is shared by all applications on that server, so classes are visible across applications. That reduces memory consumption in some cases but removes the isolation, and a library version required by one application becomes visible to all of them.

The remaining options are not defined by the product. Sequential, Compact, and Ordered do not describe a class loader policy. The term "ordered" might be confused with the class loading order setting, which is a separate attribute choosing between parent first and parent last delegation; it is not a policy value for application class loaders.

Administrators set the policy on the application server's configuration, and it works together with the class loading mode, which determines the search order. Most deployments retain Multiple because isolation prevents version collisions between applications that share a server.

First failure data capture (FFDC) writes exception summaries and incident files to the profile's ffdc directory. Retention of those files is controlled by the ExceptionFileMaximumAge property, which sets how long an FFDC file may remain before it becomes eligible for purging. The product reads FFDC settings from three separate property files, and each file is consulted at a different point in the server lifecycle. ffdcRun.properties applies while the server is running, ffdcStart.properties applies during startup processing, and ffdcStop.properties applies during shutdown. For the purge policy to behave identically in all three phases, ExceptionFileMaximumAge has to carry the same value in every one of them, which is the position stated in option C.

Options A, B, and D each leave out at least one of the files. Updating only ffdcRun.properties, for example, would change the retention age for a running server but leave startup and shutdown purges operating on the previous value, so files could be removed on an inconsistent schedule or accumulate longer than intended. Option A also refers to "ffdcStart properties" without the .properties extension and names a single file, so it fails on both counts.

The practical rule for administrators is to treat the three files as one logical configuration and edit them together whenever FFDC retention is tuned.

The error CRIMA1020E during the install phase tells the administrator that Installation Manager could not complete the update, and in this case the installation files themselves are damaged. The aim is to return to a good installation, apply the fix pack, and keep the existing configuration, with as little work as possible. The most economical approach combines the product's backup and restore tools with a file-system restore. The administrator first runs backupConfig, which saves the configuration of the profile to an archive. The installation is then repaired by restoring the file system from the last working backup, which brings back a consistent set of product files. The upgrade to the target level is applied next, and finally restoreConfig reloads the saved configuration. Option C describes this sequence.

Option A, uninstalling and re-installing the product, takes more effort because it needs a fresh installation, with the fixes reapplied to reach the required level, before the configuration can be restored. Option B restores the file system and then reconfigures the environment by hand, which is slow and error-prone, and the configuration in the file-system backup may be out of date. Option D, restoring a virtual machine snapshot and reconfiguring, has the same drawback, since the manual reconfiguration is the expensive part.

Before any restore, the administrator should stop all the processes of the installation, and should verify the result with imcl listInstalledPackages and the versionInfo command.

The node agent is represented in the cell by managed beans, and the AdminControl object of wsadmin operates on those running MBeans. A node agent MBean exposes operations including stopNode and restart, so the administrator first obtains the MBean identifier, for instance with AdminControl.queryNames for type NodeAgent and the node name, and then calls AdminControl.invoke(nodeAgentMBean, 'restart'). The node agent then restarts itself, and the deployment manager's view of the node returns to normal when the process is up. Option B describes that call.

AdminConfig, option A, works with configuration documents in the repository, and it has no method that sets server status. AdminTask offers administrative commands such as startServer and stopServer, but the command shown in option C, restartServer with the serverName parameter, is not a node agent restart operation; the node agent has its own stop and start procedures. AdminApp, option D, deals with installation and updates of applications, so updateInteractive has no relationship to server restarts, and 'restartApp' is not a valid argument.

An important practical point is that a node agent that is stopped cannot be restarted through the deployment manager, because the process that carries the MBean is not running. In that situation the node's startNode command has to be run locally on the node.

A service integration bus is made highly available by arranging for a messaging engine to be able to fail over. When a cluster is added as a bus member, the product creates a messaging engine for the cluster, and by default only one cluster member runs that engine at a time, while the other members stand ready to take over if the host server fails. The high availability manager monitors the active member, and on failure it activates the engine on another member of the cluster, restoring messaging service with the engine's persistent state held in the shared message store. Because one engine, with the ability to fail over among the four members, achieves that availability, option A is correct.

More engines are not required. Option C, one engine per member, describes a scalability configuration, in which a workload is partitioned across engines, and it adds complexity because of partitioned destinations; it is not a requirement for availability. Option D, two engines, is arbitrary and does not correspond to a rule in the product. Option B, two buses, would multiply management effort without providing failover in the way a clustered engine does.

An administrator choosing between availability and scalability should recognise that the default policy favours availability. If throughput is also a concern, additional engines can be introduced with workload sharing, along with the necessary configuration of the message stores.

Profile creation with manageprofiles records the new profile in the product's profile registry, and the registry is protected by a lock file so that two creation or deletion processes cannot modify it simultaneously. The error text "Another profile1 process is running or a lock file exists" describes this protection. Since the question states that no other WebSphere processes are active, the lock must be left over from an earlier failed or interrupted run, and the stale lock file is what blocks further attempts.

The file to remove is profileRegistry.xml_LOCK, located in the properties directory under the product installation root. Deleting it clears the condition, after which the failed profile directory and any partial registry entry should be checked and the manageprofiles command rerun. Option B is correct.

Options C and D name actual configuration artifacts, createProfile.xml and profileRegistry.xml, and neither is a lock file. Removing profileRegistry.xml would be harmful, because it is the registry that lists every profile on the installation. Option A, createProfile.xml_LOCK, resembles a plausible name but does not exist as a standard lock file.

Before deleting any lock, an administrator should verify that no manageprofiles or Profile Management Tool process is genuinely running, since removing an active lock risks registry corruption. The profile creation log, profile1_create.log, remains the authoritative place to confirm the cause.

Application security roles in an enterprise application are mapped to users, groups, or special subjects, and the special subjects are a convenient way to grant a role to broad categories of caller without naming individuals. The product supplies two principal special subjects: All Authenticated, in the application's realm or in the trusted realms, and Everyone. When the application uses external identity providers, such as when authentication is carried out by a third-party provider through a trust association or by a token from another realm, the callers belong to a realm other than the application's own. The special subject that covers any authenticated user in the trusted realms is "All authenticated in the trusted realm", which is option A.

The application-realm variant, option B, includes only users authenticated in the application's own realm, which would exclude callers who arrive from the external provider. Everyone, option D, grants the role to any caller including unauthenticated ones, which is a much weaker control than the question implies. None, option C, is not a mapping that would grant access.

When mapping roles in the administrative console during installation, or later through the Security role to user/group mapping page, administrators should prefer the narrowest subject that serves the purpose, and test with a user from the external provider to confirm the expected access.

The Java thin client is a standalone Java SE application that uses the WebSphere thin client runtime libraries to reach services in the application server. That runtime provides the support a full-function Java SE client needs: resolving objects, including JNDI lookups and remote references; security operations such as authentication to the server; and the facilities for reliability, availability, and serviceability, abbreviated RAS, which cover logging and diagnostic behaviour. What it does not provide is an application client container. Without the container, the client has to handle initialisation and service access in its own code rather than relying on declarative references and container-managed startup. That matches the wording of the question, so the correct answer is C.

The Java EE client differs on exactly this point, because it runs in the application client container, which gives easy access to those services. The applet client runs within a browser's Java plug-in and has its own limitations on what the browser permits. The ActiveX to EnterpriseJavaBeans Bridge serves non-Java ActiveX clients rather than full-function Java SE applications.

Selecting among client types is largely a question of how much container support the application needs. For a lightweight Java SE tool that only needs to call enterprise beans, the thin client is adequate; for more involved clients, the Java EE client is preferred.

Tivoli Performance Viewer, available within the administrative console, displays PMI data for servers and can record it to logs for later review. Its logging feature works at the level of the node: the viewer retrieves performance data from every server on the node that is selected, and records it, which matches option B.

The other statements misdescribe the feature. Logging does not continue indefinitely once started, so option A is wrong. It operates for a set duration, which the administrator specifies, and it ceases once that duration elapses unless it is stopped earlier. Option C is wrong because the logs can be written either as binary files or as XML, so they are not always text. Option D is wrong because the Maximum Number of Historical Files setting controls the retention of older log files: when the limit is reached, the oldest files are removed to make way for new ones, and logging goes on instead of terminating.

These characteristics shape how the viewer is best used. Short, targeted recording periods are appropriate for diagnosing a particular problem, and the saved logs can be reloaded in the viewer for analysis away from the live system. For long-term trend monitoring, administrators generally rely on external tooling that polls PMI data continuously.

Memory-to-memory session persistence uses the data replication service to copy session state between servers, so sessions survive the failure of one server without a database. The risk to avoid is concentrating the only copy of a session in a single place. Configuring more than one session replica means each session's data exists in at least two other locations, so a failover can still find the session even if a replica is lost at the same time. Option A states this principle and describes the configuration that minimises data loss.

The options mentioning GetDWLMTable are less suitable. GetDWLMTable is a plug-in setting that makes the plug-in retrieve dynamic workload management table data from the server, which concerns routing information in the Intelligent Management environment and does not govern how many copies of the session data are kept. Peer-to-peer replication, option B, copies sessions between all members of a replication domain, and it is a valid mode, but the question asks about minimising loss, which depends on the number of replicas. Server replication and client replication, options C and D, specify where the replicas are held, with different trade-offs, and the GetDWLMTable setting alone does not reduce the risk.

Administrators should size the replication domain to the number of replicas chosen, as additional copies increase network traffic and memory usage.

The linperf script is part of the IBM MustGather for performance and hang problems on Linux. Its job is to collect operating system data and diagnostic data from the Java process while the problem is occurring: it takes periodic samples of CPU, memory, and process information and signals the JVM to produce javacores, which show the threads and their stacks. Two statements about it are true. It must be executed as the root user, because several of the commands it runs, such as those capturing system-wide statistics and signalling processes owned by other accounts, need elevated privileges. And it runs for four minutes by default, sampling at regular intervals so that a sequence of snapshots shows how the problem develops. Options C and D are correct.

The remaining statements are wrong. Option A is wrong because verbose GC data is not gathered by the script; it must be enabled in the JVM beforehand if it is wanted. Option B is wrong because linperf generates javacores, not heap dumps, and heap dumps have their own collection steps. Option E is wrong because the script takes the process identifier of the JVM, and not the server name.

When using it for a hang that recurs, the administrator should start the script as soon as symptoms appear, and send the resulting archive and the SystemOut.log to IBM Support.

Installing the application server, IBM HTTP Server, and the plug-in with Installation Manager on one virtual machine produces a local web server whose plug-in configuration can be created with the Web Server Plug-ins Configuration Tool. Two statements about such a setup are true. Propagation of the plugin-cfg.xml file is supported: when the web server is defined as a node in the cell, the deployment manager or node can copy the generated plug-in file to the web server's configuration directory, so changes to applications and clusters reach the plug-in. And the installation was performed by a non-root user, so the web server cannot bind to a port below 1024; the default HTTP port 80 is privileged on Linux, and the administrator must change the port to a value above 1024, such as 8080. Options B and E are correct.

Option A is incorrect because automatic generation of the plug-in configuration remains available when the web server is defined as a managed or unmanaged node. Option C is incorrect because the configuration tool, or an equivalent definition, is still needed to establish the web server definition for the unmanaged node. Option D is incorrect because an unmanaged IHS server cannot be controlled through the administrative console, whereas administration through the IHS administration server requires a managed arrangement.

After the port change, the plug-in is regenerated and propagated, and the web server is restarted.

Modernisation is justified by business and operational outcomes, and two of the listed reasons are legitimate. Speeding in-market delivery is a central motive: moving an application to a cloud environment, and often packaging it in containers, lets teams use automated build and release pipelines, provision environments on demand, and deliver changes more often. Reducing complexity and costs is the second: consolidating infrastructure, using pay-as-you-go capacity, and retiring ageing platforms lower the burden of operating the estate. Options B and D are correct.

The remaining statements describe side effects or goals that are not reasons in themselves. Making source code simpler, option A, may occur if an application is refactored, but a move to the cloud does not simplify code, and rewriting for that purpose is an expensive end in itself. Making the application faster, option C, is not a dependable result, because performance depends on design, and an application that is moved without change usually performs much as before. A better user experience, option E, relates to the application's interface and functionality, which modernisation of the platform does not by itself change.

Transformation Advisor helps to prioritise by estimating the effort per application, so the organisation can begin with the candidates that have the best ratio of benefit to work.

Lightweight memory leak detection is a component of the Performance and Diagnostic Advisor framework. It examines Java heap behaviour, watching how heap occupancy trends after garbage collection, and issues a warning when the pattern is consistent with a leak. Because it runs inside the advisor framework in the server process, it does not need an external agent or monitoring product, and the overhead is small enough for routine use.

That design explains why the other options are wrong. Option A overstates the scope: the facility is concerned with the Java heap only and does not detect native memory leaks, which require operating-system tools or native-memory tracing. Option C misdescribes its purpose: it provides early notification that heap growth looks abnormal, not analysis of which objects or code paths are responsible. Option D is incorrect for the reason already given: no additional agent is required or used.

Once the advisor raises a notification, the next step is evidence collection. Typical follow-up includes enabling verbose garbage collection, taking a series of heap dumps, and examining them with a heap analysis tool to identify retained object paths. The lightweight detector narrows the question of whether to investigate; it does not answer where the leak originates, and an administrator should treat its output accordingly.

The Installation Verification Tool, ivt.sh, tests a profile by starting the server if necessary, checking that it opens its ports, and examining the logs for start-up messages. It takes the server name and the profile name as arguments, in the form ivt.sh server_name profile_name, and an optional port argument, -p, for use when the default port differs. To confirm that the deployment manager profile was created successfully, the administrator runs it with the deployment manager's server name, dmgr, followed by the name of the deployment manager profile. Option C has the correct form.

Option A supplies only the custom profile and omits the server name. Option B gives the deployment manager name and the custom profile, which tests the wrong profile, and adds a port number that does not correspond to the deployment manager's default administrative console port. Option D omits the profile and supplies a port that is not the deployment manager's. A custom profile contains no server before federation and customisation, so the tool could not verify it in any case.

The script should be run from the bin directory of the profile being checked. Its results are shown in the console output and written to a log file in the profile's logs directory, which the administrator can read to find the cause if a test fails.

Cross Component Trace (XCT) extends the server's log and trace framework with correlation data, and its output is governed by a correlation-level setting that accepts three values: REQUEST ID, LOG, and DATA_SNAPSHOT. REQUEST ID stamps each log and trace record with a request identifier and adds nothing else. LOG, the default level, stamps the identifier and also writes XCT log records that mark where a request begins, ends, and branches across components. DATA_SNAPSHOT includes everything LOG does and additionally captures data snapshots. Replacing LOG with REQUEST ID in the correlation-level property therefore restricts XCT to request IDs in the log and trace files, which is what option D describes.

The other statements fail on specifics. Option B is incorrect because the default setting already includes request IDs. Option C is incorrect because request IDs are retained only when the server runs in HPEL log and trace mode; basic mode does not store them. Option A misstates the service name: in wsadmin scripts, RASLoggingService is substituted for the HPEL service name when a server uses basic mode, and LoggingService is not a recognised value.

REQUEST ID is the lightest of the three levels and suits cases where cross-thread and cross-JVM correlation is needed without the added volume of XCT log records.

IBM Installation Manager keeps a registry of every package it has installed, and its command-line tool, imcl, can read that registry. Running imcl listInstalledPackages, optionally with -verbose, lists the packages and their versions in the installation location. An administrator who performed a silent installation with a response file, as a non-root user, can use that listing to confirm that the expected product and fix packs are present. Option D is correct. The command must be run by the same user and against the same Installation Manager data location that were used for the installation, because non-root installs record their data in the user's own registry.

The alternatives do not fit. Opening installed.xml by hand, option A, is not the recommended method, and the file path given is not a documented verification mechanism. The Installation Verification Tool, option B, is associated with checking a profile's server startup, not the package installation, and it is run from a profile. The administrative console, option C, has no File menu with a View Installed Packages item; it is also unavailable until a profile has been created and a server is running.

Additionally, the versionInfo command, run from the product's bin directory, reports the product and fix pack level, and is a useful complement for confirming the installed version.

A Java EE application that exposes or consumes JAX-WS services can define its web service metadata in two ways, through annotations in the code and through the webservices.xml deployment descriptor. The descriptor is optional in this model, because annotations alone are sufficient, so it is not required, which rules out option A. The JAX-WS specification, together with the web services metadata specification it builds on, establishes a precedence rule: where both sources define the same item, the information given in the deployment descriptor overrides what the annotations specify. That is the position described in option B, and it lets an administrator or assembler adjust values such as port component names without changing the source code.

Option C is incorrect because wsdeploy is associated with the older JAX-RPC model and does not apply to JAX-WS applications in this release; JAX-WS annotated classes are discovered and prepared automatically when the application is installed. Option D is also incorrect because JAX-WS applications do not require additional product-specific bindings or deployment descriptors for ordinary deployment, since the runtime assembles the endpoint from the annotations.

When a service behaves differently from the annotations, the first check should therefore be whether a webservices.xml file in the module is overriding them. Policy sets and bindings can then be attached separately for qualities of service such as security and reliable messaging.

Migration reports for enterprise applications are stored with the application's deployed configuration, and the product ties their lifetime to the application itself. A report is created on request, through the administrative console or the createMigrationReport task, and can be read with getMigrationReport or removed on demand with deleteMigrationReport. The automatic removal occurs when the application is uninstalled or redeployed, because at that moment the code that the report analysed no longer exists in its original form. Option B is correct.

The other events do not trigger deletion. Dynamic reloading of an application, option A, refreshes loaded classes after changed files are detected and leaves the stored report alone. Deploying a different application on the same server, option C, affects only that new application's own analysis. An update to an application, option D, modifies parts of an installed application; the report is not removed by that action as it is by a full redeployment.

Administrators who need to keep results should treat the report as a point-in-time artefact: export or save the report before reinstalling the application, and generate a new one afterwards. Rerunning the analysis after any redeployment ensures the findings reflect the code that is now installed.

The product can reflect many changes to a deployed application without a full redeployment, either through dynamic reloading, which applies to changes in classes and related files, or through fine-grained update operations in which individual files are added, replaced, or removed. Annotated classes are a special case. During application installation, the product scans the application's classes for annotations and uses the results to build metadata, so, for instance, servlets or web services declared by annotation are discovered at that time. When a change affects the class hierarchy of annotated classes, by adding, removing, or modifying superclasses or interfaces, the scan results can no longer be assumed accurate, and the metadata derived at installation must be regenerated.

The only action that regenerates it is a fresh installation of the application, which makes option A the correct answer. A simple restart, option B, reloads the code but reuses the stored metadata. Editing annotations manually, option C, does not apply because annotations live in the source code compiled into the archive. Modifying applications.xml, option D, would risk corrupting the deployment configuration and does not trigger a scan.

After such a change, administrators should uninstall or reinstall the updated archive, and confirm afterwards that the expected components and endpoints appear, reviewing the application's start-up messages for scan-related warnings.

Java 2 security gives WebSphere Application Server a policy-based mechanism for controlling which resources application code may access. Permissions are granted through policy files at several levels. Server-wide defaults live in files such as server.policy and the product's default policy, while permissions specific to one application are placed in a was.policy file packaged in the application's META-INF directory. The supported way to edit that file is the PolicyTool utility, which provides a graphical editor for policy files, including adding codebase entries and granting permissions such as file, socket, or runtime permissions. Option B is correct.

The alternatives are not valid. A file named was.policy.props does not exist as a policy file. The keytool utility manages keys, certificates, and keystores, so it addresses SSL and signing, and not permission grants. An app.policy file is a name used by other products and is not part of this runtime's policy structure.

Because an incorrectly granted permission weakens the sandbox, administrators should grant only the specific permissions an application demonstrably needs, and should rely on the product's tracing of AccessControlException messages to identify what was missing. Java 2 security must also be enabled for these files to have any effect, and an application restart is required for changes to apply.

PerfServlet exposes PMI data from the application server in XML form so that external tools can collect it. It runs as an application inside the server it monitors and gathers data on request, so its cost grows with the amount of data it has to assemble. Two of the listed factors increase that amount directly. The number of application servers in the cell matters because data must be collected from each server, and the number of resources that are configured, such as data sources, thread pools, and queues, matters because each resource has its own counters to read and report. Options B and E are correct.

The number of PMI counters is a closely related factor, but a given PMI statistic set size is configured separately, and the question's emphasis on consistently high response times across all nodes points to the scale of the topology and its resources. The number of monitoring agents, option C, does not add to the cost within the server itself, since the polling frequency is controlled by the client. The number of users, option D, affects application load but does not determine the size of the PerfServlet response.

To limit the overhead, administrators can lower the PMI statistic set to Basic, request data for specific modules instead of the whole cell, and lengthen the polling interval.

Intelligent Management adds several autonomic managers to a Network Deployment cell, and each has a distinct responsibility. The Application Placement Controller (APC) decides where application instances should run and starts or stops them to satisfy demand and service policies. The Autonomic Request Flow Manager (ARFM) governs request flow at the on demand router, applying prioritisation and queuing so that work is admitted according to service-policy goals. The Health Management component monitors defined health conditions and carries out corrective actions such as restarting a server. Dynamic Workload Management (DWLM) is the manager that balances requests among the available nodes.

DWLM adjusts routing weights dynamically, using runtime information about response times and load, so that traffic is spread to regulate performance. It also keeps the routing layer informed of the current application state: when APC changes the running infrastructure, for instance by starting an additional instance, DWLM updates application status so the on demand router can use or avoid the affected servers. Option C matches both parts of the description.

Option B places and sizes application instances but does not itself distribute individual requests. Option D manages flow and priority, not node-level balancing, and Option A reacts to health policy violations. The question's emphasis on balancing requests and dynamically updating status points to DWLM.

The error message states that the installation package requires components supplied by other packages, which means Installation Manager has found a prerequisite that is missing from the system. On a Windows host, IBM HTTP Server depends on the Microsoft Visual C++ runtime libraries. When the fix pack raises the runtime level required, an older or absent redistributable causes Installation Manager's prerequisite check to fail, and the package cannot be installed until the needed runtime is present. Installing the Visual C++ Redistributable Package of the version stated in the product's prerequisites resolves the failure. Option C is correct.

The other responses do not address the missing component. Regenerating the plug-in configuration, option A, affects the connection between the web server and application servers, and it has no bearing on the prerequisite check. Enabling an Install module, option B, is not a concept in this context. Disabling package checking, option D, may seem tempting, but it would bypass the check without supplying the missing libraries, so the web server would probably fail to start or run incorrectly afterwards.

Before upgrading IHS on Windows, administrators should review the detailed system requirements for the target fix pack, install the required runtime, stop the web server and its administration service, and then rerun the upgrade through Installation Manager.

Applications deployed to an application server are started during server startup, and the product provides a setting to control the order. On the application's configuration page in the console, and as an attribute in wsadmin, there is a Startup order parameter, which accepts an integer. Applications with lower values start before those with higher values, so an administrator can start a shared service application before the applications that depend on it. Option D is correct.

Option A is wrong because the ordering is supported. Option C is wrong because the applications are not started in the order in which they were defined or installed; without ordering values, the sequence is not something that can be relied on. Option B concerns a different parameter, "Launch application before server completes startup", which determines whether the server waits for the application to start before it declares itself started and accepts requests. That is related to startup behaviour but does not set the order among applications.

Administrators typically combine the two settings: the startup order sets the sequence, and the launch-before-completion option makes sure a critical application is fully up before the server opens for traffic. The values should be checked after changes, since the product starts applications in parallel by default when ordering is not specified, and the server log records the start messages for confirmation.

A federated repository realm combines several user registries, such as LDAP directories and a file-based repository, into one virtual realm that WebSphere Application Server uses for authentication and authorisation. Each repository contributes a portion of the overall name space, and the realm must give every user and group a unique distinguished name. To avoid collisions and to make the combined tree coherent, each repository is mapped to a base entry within the realm, and the realm defines which entity types, such as PersonAccount and Group, are supported and where new entries of each type are created. In the console, this is done by configuring the supported entity types and specifying a base entry for the default parent. Option B is correct.

The other items are part of repository setup but do not accomplish this particular requirement. Group attribute definitions, option A, tell the repository how group membership is read. The property-to-LDAP-attribute mapping, option C, translates logical property names to directory attributes for one repository. A baseDN, option D, is defined within each repository configuration to identify the subtree used, which is a precondition for the realm's base entries but is not what allows more than one repository below the realm.

When adding repositories, administrators must also verify that the base entries are unique and do not overlap in the realm's name space, because overlapping entries cause ambiguous lookups.

A Java EE 6 application can describe its components through annotations in the code, through deployment descriptors, or through both. At installation time the product scans the application's classes, reads the annotations, and merges that information with whatever the deployment descriptors state, producing the metadata it uses at run time. That metadata is stored with the installed application, so a change to a descriptor, or to any element that changes how annotations are interpreted, is not picked up simply by changing a file in place or by restarting the application, because the stored result of the earlier scan remains in effect. To make the product repeat the scan and rebuild the metadata, the administrator reinstalls the application, which is option C.

Option A, updating files through the administrative console, is a way of delivering changed files, but it does not by itself guarantee a rescan of annotated classes. Option B, restarting, reloads the code but reuses the existing metadata. Option D, editing server.xml, targets the server configuration, and the file does not hold the application's deployment descriptor or its annotation metadata.

After reinstalling, administrators should confirm the intended components were discovered, for example by checking the module and servlet listings in the console, and should preserve bindings and mappings by supplying them again or using a saved binding file. In clustered environments the new version is synchronised to every node before the application starts.

Node synchronization copies configuration from the deployment manager's master repository to each node's local copy. To keep this inexpensive, the node agent and deployment manager use an optimised algorithm that tracks changes through checksums or digests, so documents that appear unchanged are not re-sent. The Synchronize action uses that normal, optimised algorithm and is therefore faster. Its weakness is that it relies on its recorded state: if a file on the node was edited by hand, the optimisation can consider the file current and skip it, so the mismatch survives. Option A states exactly this trade-off.

Full Resynchronize clears the optimisation data and performs the synchronisation again from scratch, comparing and replacing node files as required, so it corrects node-to-cell mismatches caused by manual edits or other discrepancies. It takes longer, which is why it is not the routine choice.

Option B is incorrect because synchronisation applies to managed nodes; unmanaged nodes have no node agent to synchronise. Option C is incorrect because Synchronize remains available at any time after the first synchronisation, and automatic synchronisation also runs on a schedule. Option D is incorrect because both actions are scoped to the selected node, not to the entire cell.

An administrator who suspects drift after direct file changes on a node should choose Full Resynchronize, and should avoid editing node files outside the deployment manager.

WebSphere Application Server can run on Amazon Elastic Container Service with the Fargate launch type, in which containers are scheduled without the user managing the underlying virtual machines. IBM's support position for the traditional product in this environment is that the Network Deployment edition can be deployed in ECS using WebSphere Application Server ND licences, which is option D. The licence entitlement is the basis for the deployment, and it follows the Passport Advantage rules for use in public cloud.

The alternatives contradict that position. Option B suggests the Base edition can be deployed using ND licences, an entitlement mismatch, since the deployment is of the Network Deployment product, not Base. Options A and C concern clustering. On Fargate, containers are ephemeral and lack the managed host that the Network Deployment cell topology, with its deployment manager and node agents, assumes, so traditional ND clustering is not supported in that environment; scaling is provided by running multiple container instances behind a load balancer. Option C compounds the error by stating that ND clustering is supported only on ECS VMs, a claim that does not accurately describe the supported topologies.

Teams migrating to Fargate usually treat each container as a stand-alone server and rely on external session stores or stateless design in place of replication within a cell.

Security auditing produces records that must be trustworthy if they are to serve as evidence, so the product lets administrators protect the audit data from modification and disclosure. The binary log audit service provider writes audit records to binary log files and offers two protections: signing and encryption. Signing uses a key to produce signatures that allow later verification that a record has not been altered. Encryption protects the confidentiality of the content. Using the binary log provider with both signing and encryption enabled safeguards the data against tampering, which is the position stated in option D.

The other choices describe mechanisms that either do not exist or do not combine as claimed. The SMF emitter, mentioned in options A and C, belongs to the System Management Facilities on z/OS and writes audit records to SMF, relying on that platform's own facilities; it is not the product's means for signing and encrypting the data in a distributed environment. Option B refers to a third-party key, but the signing and encryption keys used by the provider are taken from the product's own configured key stores, so no external key is the safeguard.

To use these features, the administrator should configure the audit service provider in the administrative console with keystores holding the signing and encryption certificates, and the auditor should be given the role to view the records.

The dynamic cache service uses templates, meaning the JSP or servlet entries that carry the output of a particular resource, and it invalidates cached entries based on those templates when the underlying resources change. When a JSP is reloaded after being modified, the cache by default invalidates the template's cached entries so that stale output built from the old version is not served. The custom property com.ibm.ws.cache.CacheConfig.disableTemplateInvalidation changes that behaviour. Setting it to true disables template-based invalidations during JSP reloads, which matches option B.

Option A and option D state the opposite effect, as both describe the property enabling invalidation. Option C describes the effect as occurring during JSP caching, but the trigger is the reloading of the JSP, not the act of caching it, so the wording does not fit.

The setting suits cases in which JSPs are reloaded frequently, for instance in an environment where files are touched by a deployment process without content change, and the resulting invalidations would empty the cache and reduce its benefit. Administrators accept a trade-off, because with invalidation disabled a changed JSP may continue to be served from cache until entries expire or are invalidated by another mechanism, so the property should be applied with an understanding of the content update process. It is configured as a JVM custom property for the server.