CCNA Ingest Questions

Option A is correct because IRE identification rules depend on specific attributes (such as serial number, name, or IP address) being present in the payload; if those required attributes are missing, the engine cannot match the incoming data to an existing CI and raises a processing error. Option D is correct because the discovery source value drives precedence and reconciliation logic in IRE; an unregistered or malformed discovery source string prevents the engine from evaluating precedence correctly and results in an error. Option E is correct because when a payload references a parent CI (for example via a relation or lookup), IRE must resolve that parent to a valid CI record; if the parent cannot be identified, the dependent CI cannot be processed and an error occurs.

Option B is not relevant because UI Policies affect form behavior in the platform UI, not IRE payload processing. Option C is not relevant because IRE does not impose a 1,000-record-per-batch limit as a common error trigger; batch size is a general import consideration, not an IRE identification/reconciliation failure cause.

Option A is correct because CI Class Manager identification rules define which attributes (such as serial number, name, or IP address) are used to uniquely identify a CI; if these rules are misconfigured or missing for the affected class, incoming records will not match existing CIs and duplicates will be created. Option D is correct because the Identification and Reconciliation Engine (IRE) processing logs and payload results show exactly how each incoming record was evaluated, including which identification rules were applied and why a match failed, which is essential for diagnosing the root cause of duplicate CIs. Option B is incorrect because hiding duplicates via ACLs only masks the symptom and does not resolve the underlying identification problem.

Option C is incorrect because REST Message timeout limits affect outbound request performance, not CI matching or deduplication. Option E is incorrect because deleting and recreating Discovery schedules is a destructive, unrelated action that would not address duplicate CI creation from an integration.

Option A is correct because the Identification and Reconciliation Engine (IRE) requires the payload to include properly formatted related items or relationship blocks; if the structure is malformed, the IRE cannot create the relationships. Option C is correct because both the source and target CIs in a relationship payload must successfully pass identification; if either CI fails to identify or be created, the relationship cannot be established. Option D is correct because the relationship type (for example, 'Runs on::Runs') must exist and be active in the cmdb_rel_type table, otherwise the IRE will reject or skip the relationship.

Option B is not correct because client scripts on the target CI table do not block IRE relationship processing, which operates at the server/API level. Option E is not correct because the Discovery status schedule setting is unrelated to custom data integration relationship handling.

Option B is correct because ingesting data through the Identification and Reconciliation Engine (IRE) requires the IntegrationHub action or script step to explicitly call the IRE API, typically via the sn_cmdb.IdentificationEngine script include, so the payload is processed by IRE rather than inserted directly. Option E is correct because the IRE expects a properly structured JSON payload containing valid CI class names, identification attributes (such as serial_number, name, or sys_class_name), and related item entries so it can identify, reconcile, and create or update CIs correctly. Option A is not needed because Service Mapping horizontal patterns are used for service discovery topology mapping, not for REST-based CMDB ingestion via IRE.

Option C is not needed because Discovery schedules and IP ranges apply to Discovery, not to an IntegrationHub REST step. Option D is not needed because legacy Transform Maps are bypassed when using the IRE API for identification and reconciliation.

Option A is correct because the Identification and Reconciliation Engine honors the 'ignore empty values' setting on an attribute; when the incoming payload supplies a blank value and that flag is enabled, the IRE skips the update rather than overwriting the existing value. Option C is correct because Data Source Precedence determines which source is authoritative for a given attribute; if the incoming data source has lower precedence than the source that last populated the attribute, the IRE will not overwrite the existing value. Option D is correct because the IRE performs a value comparison and skips the write when the incoming value is identical to the value already stored, avoiding a no-op update.

Option B is not a valid reason because IRE processing does not evaluate table-level Business Rules to decide whether to update an attribute; Business Rules run on record operations, not on the IRE's attribute-level reconciliation logic. Option E is not a valid reason because read access to sys_user is unrelated to attribute-level update decisions in the IRE; the IRE's skip logic is driven by attribute configuration, data source precedence, and value comparison, not by the executing user's access to an unrelated table.

The Identification and Reconciliation Engine (IRE) processes import set rows after they are marked 'Processed' by the transform. When IRE rejects a payload—due to missing required attributes, duplicate detection conflicts, or failed reconciliation rules—it does not create or update CIs, but the import set row status remains 'Processed' because the transform itself succeeded. Detailed rejection reasons, including the specific payload and rule that failed, are written to the CMDB Integration Results table (cmdb_integration_log) and IRE processing logs, not to the standard transform warnings.

Therefore, option B is the correct place to investigate IRE rejections.

Option B is correct because payload identification failures often stem from the target class's identification rules in CI Class Manager not matching the attributes being sent, so verifying that the mapped attributes satisfy the rule criteria is essential. Option C is correct because the CMDB Integration Results and Identification and Reconciliation Engine (IRE) execution logs provide the detailed error descriptions needed to pinpoint why identification is failing after RTE processing. Option E is correct because RTE relies on the field map to translate source payload fields into the mandatory identification attributes (such as serial number, name, or sys_class_name) required by the identification rules, and a mis-mapping directly causes payload identification errors.

Option A is not appropriate because restarting MID Servers does not address identification logic or field mapping issues and would only disrupt data collection. Option D is not appropriate because modifying web server memory allocation via system properties is unrelated to RTE payload identification and would not resolve mapping or identification rule mismatches.

Option A is correct because switch ports are ingested as dependent CI records tied to the parent switch via the IRE (Identification and Reconciliation Engine); if the dependent relationship payload is malformed, fails IRE validation, or is omitted entirely, the parent switch is created but its port CIs are dropped. Option D is correct because the discovery pattern (e.g., the SNMP-based network switch pattern) is what parses and populates the switch port table; if that port-parsing step is removed or excluded from the pattern, switches still get discovered while ports never get created. Option B is not relevant because cmdb_ci_ip_address read-only access affects IP address CI writes, not switch port ingestion.

Option C is not relevant because Data Source Precedence rules resolve conflicts between data sources for existing records; they do not cause ports to be marked deprecated or prevent their initial discovery. Option E is not relevant because running discovery outside business hours only affects timing, not whether switch port data is parsed and ingested.

Option A is correct because identification rules must rely on attributes that are unique and immutable, such as serial numbers or hardware asset tags, so the same CI is consistently matched rather than duplicated or misidentified when other fields change. Option B is correct because identification rules are evaluated in order, so placing the most reliable and specific criteria first ensures the strongest match is attempted before broader, less precise rules are considered. Option D is correct because volatile attributes like IP address or hostname alone can change when devices move networks, causing false matches or duplicate CIs; they should be combined with stable identifiers or avoided as sole primary identifiers.

Option C is incorrect because custom CI classes should extend cmdb_ci (or an appropriate CMDB base class) to inherit the identification engine behavior and required fields, not be created on unrelated custom tables. Option E is incorrect because cramming every attribute into one compound rule makes identification overly restrictive and brittle, so any single changed attribute breaks the match and creates duplicates.

Option C is correct because the CMDB Integration Results and IRE Execution Logs record the exact outcome of each IRE payload, including rejection reasons such as missing required attributes, duplicate detection, or identification failures, which is the fastest way to see why records are not being inserted into the CMDB. Option D is correct because the IRE requires valid identification rules for the target CI class; if the software license class lacks an active identification rule (or the rule is not published), the IRE cannot uniquely identify or create the CI and will reject the payload. Option E is correct because RTE relies on field mappings and data stream definitions to transform source staging fields into the IRE payload attributes; if a mandatory target attribute is unmapped or mapped incorrectly, the IRE payload will be incomplete and the insert will fail.

Option A is not relevant because SLA definitions govern task/response time tracking, not IRE payload processing or CMDB insertion. Option B is not relevant because UI Macros control form rendering and decorators, which have no bearing on RTE-to-IRE data flow or CMDB record creation.

Option B is correct because the Identification and Reconciliation Engine (IRE) is the ServiceNow mechanism that applies identification rules, reconciliation rules, and data source precedence to deduplicate and govern CI data as it is ingested, which is essential for maintaining CMDB data hygiene in a CSDM implementation. Option D is correct because clear data source ownership and precedence rules ensure that when multiple sources (e.g., discovery, imports, integrations) supply the same CI attribute, the authoritative value is deterministically chosen, which is a core CSDM data governance principle. Option A is incorrect because disabling identification rules on base classes would allow duplicate and conflicting records to proliferate, directly undermining CMDB integrity.

Option C is incorrect because relying exclusively on weekly manual spreadsheet imports is neither scalable nor timely for enterprise infrastructure CIs and violates CSDM guidance favoring automated, near-real-time ingestion. Option E is incorrect because bypassing IRE with legacy transform maps and direct GlideRecord insertions skips identification and reconciliation, producing duplicates and inconsistent data despite any perceived performance gain.

Option A is correct because CI identification rules defined in CI Class Manager determine which attributes (e.g., serial number, name, IP address) uniquely identify a CI within each class; without verified, class-specific identification rules, incoming records cannot be reliably matched to existing CIs and duplicates will proliferate. Option C is correct because the Identification and Reconciliation Engine (IRE) is the ServiceNow mechanism that applies those identification rules, reconciles duplicates, and enforces data-source precedence; bypassing it with direct GlideRecord inserts into cmdb_ci tables skips deduplication and reconciliation entirely. Option E is correct because every payload must carry a consistent, standardized discovery source value so IRE can apply the correct data source precedence and track record provenance; inconsistent or missing discovery source strings cause IRE to treat records as unrelated and create duplicates.

Option B is not correct because Client Scripts run in the browser on form load/change/submit and have no role in validating inbound REST payloads; server-side validation belongs in Scripted REST APIs, business rules, or IRE data source rules. Option D is not correct because Cascade Delete on reference fields controls deletion behavior of related records and does nothing to ensure data integrity or prevent duplication during ingestion; in fact, it can cause unintended mass deletions of related CIs.

Option A is correct because the Identification and Reconciliation Engine (IRE) relies on identification rules configured in CI Class Manager to match incoming records to existing CIs; without robust rules, Discovery, Service Graph Connectors, and spreadsheet imports would create duplicate CIs instead of updating the correct record. Option C is correct because each integration and manual import must write a unique, standardized discovery source string (e.g., 'ServiceNow Discovery', 'SGC-Azure', 'Manual-Import-Finance') so the IRE can track provenance, apply source-specific precedence, and enable auditing or rollback per source. Option E is correct because Data Source Precedence rules determine which source wins when multiple sources update the same CI attribute, which is essential when Discovery, connectors, and manual imports supply conflicting values.

Option B is incorrect because collapsing all sources into the default 'Discovery' string destroys provenance and makes precedence, auditing, and troubleshooting impossible. Option D is incorrect because bypassing the IRE for spreadsheet imports allows unrestricted, unreconciled inserts and updates that create duplicates and corrupt CI relationships, defeating data integrity.

Option A is correct because Discovery Schedules define the target IP ranges (or individual IPs) to probe and attach the credentials (Windows, SSH, SNMP, etc.) needed to authenticate and collect data from the discovered servers; without a schedule and valid credentials, Discovery cannot ingest anything. Option B is correct because MID Servers are the on-premises execution components that actually perform the probes and scans; they must have network reachability (routing/firewall rules) to each target VLAN, otherwise the schedules in A have no path to the devices. Option C is incorrect because transform maps typically coalesce on a unique identifier such as serial number, name, or asset tag, not sys_id, which is a system-generated GUID and not a meaningful match key for imported data.

Option D is incorrect because Service Mapping uses its own patterns and topology discovery; custom Business Rules on cmdb_ci are not a Discovery ingestion requirement and do not simulate Service Mapping. Option E is incorrect because disabling the Identification and Reconciliation Engine (IRE) globally would break deduplication and CI creation/update, harming rather than helping Discovery ingestion.

Option B is correct because Data Source Precedence rules are designed to control which data sources are authorized to update specific attributes on a record, so an administrator can permit one integration to write certain fields while preventing others from overwriting them. Option D is correct because precedence rules defined on a parent class are inherited by child classes through the class hierarchy, unless the child class has its own explicitly defined rule that overrides the inherited behavior. Option E is correct because when no attribute-level precedence rule exists, the Identification and Reconciliation Engine (IRE) applies its default precedence logic rather than blocking the update outright.

Option A is incorrect because Data Source Precedence rules are configured in the Data Source Precedence module/table (e.g., sys_data_source_precedence), not in the System Log (syslog) table, which records system events. Option C is incorrect because legacy transform maps that bypass the IRE do not automatically honor Data Source Precedence rules; those rules are enforced through the IRE reconciliation process.

Option A is correct because the RTE Data Stream Definition and its field maps define how incoming source records are parsed and mapped into the target CMDB schema, which is the essential first stage of any RTE-based ingestion. Option C is correct because the IRE Payload structure or CI class mapping definition determines how the transformed data is classified and identified as the proper CMDB CI class, which is required for the Identification and Reconciliation Engine to create or update CIs correctly. Option B is not required because Discovery schedules and IP ranges only control how Discovery probes collect data, not how RTE ingests and maps it into the CMDB.

Option D is not required because Service Mapping application pattern criteria are used to build service models, not to ingest CI data into the CMDB. Option E is not required because Legacy Transform Map Coalesce scripts belong to the older transform-map approach, not the RTE/IRE ingestion path.

Service Graph Connectors (A) are built on the Identification and Reconciliation Engine and call IRE natively to deduplicate and reconcile incoming third-party data into the CMDB. ServiceNow Discovery (E) also natively invokes IRE when it creates or updates CIs, ensuring discovered data is identified and reconciled against existing records. Direct GlideRecord inserts (B) bypass IRE unless explicitly called, so they do not natively invoke it.

Email Inbound Actions creating incident records (C) operate on the task/incident tables, not the CMDB, and never touch IRE. Legacy Transform Maps with standard Coalesce settings (D) use coalesce-based matching rather than IRE, so they do not natively invoke the engine.

The Robust Transform Engine (RTE) is ServiceNow's data-transformation framework used by CMDB integrations and Import Sets to normalize incoming payloads before they reach the Identification and Reconciliation Engine (IRE). Option C is correct because RTE is specifically designed to parse and flatten complex hierarchical JSON or XML structures into the structured, tabular rows that IRE requires for CI identification and reconciliation. Option E is correct because RTE provides a library of transform functions — including string trimming, concatenation, splitting, and regex-based mapping — that can be applied to fields during ingestion to standardize values.

Option A is incorrect because authentication and session management for inbound REST calls are handled by the REST API framework, OAuth, and authentication policies, not by RTE. Option B is incorrect because RTE is a transformation layer and does not replace the underlying relational database with an in-memory graph store. Option D is incorrect because RTE only transforms data; it does not create ITSM Change Requests, which would require separate workflow or business-rule logic.

Option B is correct because Data Source Precedence in the CMDB can be configured at the global level (applying to all CI classes) as well as at the individual CI class level, allowing administrators to tailor precedence granularly where needed. Option D is correct because the core purpose of Data Source Precedence rules is to determine which discovery source (e.g., ServiceNow Discovery, SCCM, manual entry) is authoritative for specific CI attributes when multiple sources attempt to update the same CI, resolving conflicts by source priority. Option A is incorrect because Data Source Precedence applies to data processed through the Identification and Reconciliation Engine (IRE), not just legacy Import Sets without Transform Maps.

Option C is incorrect because Data Source Precedence does not perform automatic deletion or aging of CIs; it only governs which source's data wins during updates. Option E is incorrect because Data Source Precedence works alongside Identification Rules within the IRE—it does not replace them, as Identification Rules are still required to determine CI uniqueness and matching.