The user wants a data model with sample data and an overview of all relevant relationships for Services, SLAs, Incidents (Inc), etc. for an ITSM solution based on ServiceNow CSDM 5.0 model (Common Service Data Model). The request is in German, so I should respond in German. Let me think about CSDM (Common Service Data Data Model) - specifically CSDM 5.0 which is the latest version (as of my knowledge). CSDM 4.0 was released around late 2022/2023, and CSDM 5.0 came later (around 2024). Key entities in CSDM: **CSDM 4.0/5.0 main domains:** 1. **Design Value Stream**: Application Services, Service Offerings, Service Portfolios (Consumer/Producer), Business Applications, Application Services, Technical Services, Service Catalogs 2. **Sell/Consume Value Stream**: Service Offerings, Subscriptions, Commitments (SLA, OLA, UC), Service Level Targets 3. **Operate Value Stream**: Configuration Items (CI), CMDB relationships **Core tables in CSDM:** Design Value Stream: - `apm_application` (Business Application) - actually service Entitlement... Let me recall the actual table names: - Business Application: `apm_application` (Application Portfolio Management) - In CSDM v4, Business Applications moved to `apm_application` table (from `cmdb_ci_business_app`) - Service Portfolio: `service_portfolio` - Service (as service producer): "Service" records - `service` table? In CSDM 4 there's a new "Service" table that represents what the organization offers. The `service` table (extends cmdb?) Actually in CSDM v4, there's a distinction: "Service" (the service itself, `service` table) and "Service Offering" (`service_offering` table). - Service Offering: `service_offering` - Application Service: `cmdb_ci_service_discovered` (formerly cmdb_ci_service), Application Service CIs - Technical Service: `cmdb_ci_service_technical` - Service Catalog: `service_catalog` Sell/Consume: - Service Subscription: `service_subscription` - Service Commitment: `sla_service_commitment` (types: SLA, OLA, UC) - Service Level Target: `sla_service_level_target` (target metrics like availability %, response time) - Service Level Definition: `sla_service_definition`? Actually there's `sla_definition`... Let me recall: Service Level Definition `sla_definition`? In CSDM, Service Level Definitions include: Service Level Definition (metric), Service Level Target (target value), Service Commitment (SLA/OLA/UC type). Operate Value Stream: - CIs: `cmdb_ci_*` tables - Dynamic CI Groups (DCG): `cmdb_ci_dyn_group`? Actually `u_dynamic_ci_group`? The OOTB table is `cmdb_ci_dynamic_group`? Hmm. Dynamic CI Group table: `cmdb_ci_dyn_group`? I believe it's `cmdb_ci_dyn_group`... Actually the table name for Dynamic CI Groups is `cmdb_ci_dyn_group`? Let me think - I recall it being `cmdb_ci_dyn_group` in some documentation but also `u_dynamic_ci_group`... The standard one: Dynamic CI Group is stored in `cmdb_ci_dyn_group`. Hmm, I'm not 100% sure. I think the correct one is `cmdb_ci_dyn_group`. Actually, I remember the Dynamic CI Group table is `cmdb_ci_dyn_group`. There's also "Application Service" auto-populated by DCG queries. Relationships (cmdb_rel_ci types): - "Consumes::Consumed by" between Business Application and Application Service? Actually "Runs on::Runs" etc. - Business Application "Owned by::Owned by" Application Service: The relationship "Runs on::Runs" — Business Application -> Application Service? In CSDM: Application Service "Supports::Supported by" Business Application. - Application Service "Contains::Contained by" Configuration Items (Servers, Databases, etc.) - Service Offering "Is deployed as::Deployed version of" Application Service? Actually relationship: Service Offering -> Application Service "Is deployed as::Deployed as"? Let me recall: In CSDM, Service Offering is related to Application Service via "Is deployed as::Deployed version of"? I think the relationship type is "Is deployed as::Deployed version of" between Application Service and Service Offering. Hmm. Let me recall CSDM 4 relationship guidance: - Business Application → Application Service: "Consumes::Consumed by"? No... - The recommended: Application Service "Supports::Supported by" Business Application. (Application Service supports Business Application) - Service Offering "Is deployed as::Deployed version of"? I recall "Service Offering -> Application Service: Is deployed as::Deployed version of". Yes! In CSDM, the relationship between Service Offering and Application Service is "Is deployed as::Deployed version of". - Application Service "Contains::Contained by" Infrastructure CIs like servers: "Contains::Contained by"? Actually for servers it's "Runs on::Runs" (Application Service runs on Server). "Contains::Contained by" is used for network gear, IP devices? The CSDM guidance: Application Service "Contains::Contained by" Database, "Runs on::Runs" Server? Let me recall: - Application Service -> Server: "Runs on::Runs" - Application Service -> Database: "Contains::Contained by" - Application Service -> network device: "Runs on::Runs"? Hmm, network gear typically "Connects to::Connected by" but Application Services use "Contains::Contained by" for network segments? Actually network devices relate to Application Service via "Contains::Contained by"? I'm not sure. Let me think about CSDM recommended relationships: - Application Service "Runs on::Runs" Server (cmdb_ci_server) - Application Service "Contains::Contained by" Database (cmdb_ci_database) - Application Service "Contains::Contained by" Datacenter? No, that's "Hosted in::Hosts"? Hmm. - Application Service "Contains::Contained by" Network gear (cmdb_ci_netgear)? I believe CSDM says network devices: Application Service "Contains::Contained by" Network Gear? Not sure. Let me structure the answer pragmatically: The user wants a data model with sample data and an overview of relevant relationships for Services, SLAs, Incidents, etc. based on ServiceNow CSDM 5. This is a consulting/documentation request. I should provide: 1. Overview of CSDM 5 structure (Design Value Stream, Sell/Consume, Operate, Technical/Business layers) 2. Core tables/classes with key fields 3. Sample data (realistic German company scenario - e.g., "E-Mail Service", "ERP Service") 4. Relationship matrix/diagram 5. How ITSM (Incident, Problem, Change, Request) connects to Service Offerings and CIs 6. Maybe UML-like diagram in text/ASCII or Mermaid 7. Notes on SLA/Commitments (Service Commitment, Service Level Target, Service Level Definition), OLA/UC distinction 8. Subscription model (Service Subscription for consumers) I should be careful about accuracy of table names. Let me list the actual ServiceNow table names for CSDM: **Design Value Stream:** - Service Portfolio: `service_portfolio` (module: Design > Portfolios) - Service: `service` (new in CSDM v4; represents the service itself; consumers of service are via offerings) — The "Service" table exists in the `service` namespace? I believe the table name is `service` (scoped app "Service Portfolio"?). Hmm. In CSDM v4, "Service" records are stored in the `service` table. Yes, there's a new `service` table. Service Offering remains `service_offering`. - Service Offering: `service_offering` - Service Catalog (consumer catalog): `service_catalog`? The CSDM v4 introduced "Service Catalog" table? Hmm, actually there's `m2m_sp_catalog`... I recall in CSDM v4 "Service Catalog" is a new class: `service_catalog`? Let me think... Yes, CSDM v4 added "Service Catalog" entity to group Service Offerings for catalog display. Table: `service_catalog`. - Business Application: `apm_application` (moved from `cmdb_ci_business_app` in CSDM v4). Both exist; APM app uses apm_application. In CSDM 4 guidance, Business Applications are now in `apm_application`. - Application Service: `cmdb_ci_service_discovered` (CSDM v4 renamed cmdb_ci_service to cmdb_ci_service_discovered; there are also `cmdb_ci_service_auto`? Actually "Service" CI class `cmdb_ci_service` became `cmdb_ci_service_discovered`. There are subclasses: `cmdb_ci_service_discovered`? Hmm wait. Let me recall: In CSDM v3, Application Service = `cmdb_ci_service` (Service CI class). In CSDM v4, they renamed: "Service" class `cmdb_ci_service` → `cmdb_ci_service_discovered`? I believe: `cmdb_ci_service` was renamed to `cmdb_ci_service_discovered`, and new classes added: `cmdb_ci_service_auto`? Hmm, I'm not fully certain. Let me recall CSDM v4 classes for Application Services: - `cmdb_ci_service_discovered` — discovered Application Services (from Discovery/SAM) - `cmdb_ci_service_computed` — computed (ServiceGraph connectors?) - `cmdb_ci_service_manual`? Hmm. Actually I recall: "Service" CI hierarchy: cmdb_ci_service (parent, renamed?), subclasses: cmdb_ci_service_discovered, cmdb_ci_service_computed, cmdb_ci_service_dynamic? Hmm... From ServiceNow docs (CSDM v4): "Application Service class family: cmdb_ci_service_discovered (Discovered), cmdb_ci_service_computed (Computed), cmdb_ci_service_dynamic (Dynamic), cmdb_ci_service_system (System)?" I'm not sure about the exact subclasses. I recall there are: Discovered (`cmdb_ci_service_discovered`), Computed (`cmdb_ci_service_computed`), Dynamic? Hmm, Dynamic CI Groups produce "Dynamic" application services stored where? I think DCG-populated Application Services are still stored in `cmdb_ci_service_discovered`? No... Let me think about what I know with confidence: - In CSDM v3: Application Service = `cmdb_ci_service`. Dynamic CI Groups auto-populate Application Services in that class. - In CSDM v4: The Application Service class is now `cmdb_ci_service_discovered`. Subclasses: `cmdb_ci_service_computed`, `cmdb_ci_service_dynamic`? Hmm... Actually I now recall the v4 documentation: "Application Service (cmdb_ci_service_discovered)" with child classes "Computed (cmdb_ci_service_computed)" and "Dynamic (cmdb_ci_service_dynamic)"? Hmm, but I'm not fully sure about `cmdb_ci_service_dynamic`. There's also `cmdb_ci_service_technical` for Technical Services. And `cmdb_ci_service_business`? No. Hmm. Actually, I remember now: In CSDM v4, the "Service" CI class family includes: - `cmdb_ci_service_discovered` — Application Service (discovered) - `cmdb_ci_service_computed` — computed application services (e.g., from Service Graph Connectors) - `cmdb_ci_service_dynamic`? I'm genuinely unsure. There IS a class for dynamic services... I recall "Service [cmdb_ci_service_dynamic]"? Hmm. To be safe, I can mention `cmdb_ci_service_discovered` as the main Application Service class (post CSDM v4) and note that in older versions it was `cmdb_ci_service`, without enumerating all subclasses. That's safer. - Technical Service: `cmdb_ci_service_technical` (CSDM v4 introduced Technical Services as first-class CIs). - Business Application: `apm_application`. **Sell/Consume Value Stream:** - Service Subscription: `service_subscription` (Subscription-based consumption; consumer + service offering) - Service Commitment: `sla_service_commitment` — with fields: service offering, commitment type (SLA, OLA, UC), schedule, timezone. Table for commitments is `sla_service_commitment`. Types stored in field `commitment_type`: "SLA", "OLA", "UC". - Service Level Target: `sla_service_level_target` — linked to commitment; has target metric (e.g., Availability %, Response time, Resolution time) referencing "Service Level Definition". - Service Level Definition: `sla_service_definition`? Hmm. The table for Service Level Definitions... I recall `sla_service_definition`? Let me think. In ServiceNow, Service Level Definitions for CSDM are in table `sla_service_definition`? Hmm, hmm. Actually I recall the CSDM Sell/Consume tables: - Service Commitment: `sla_service_commitment` - Service Level Target: `sla_service_level_target` - Service Level Definition: `sla_service_definition`? or `sla_definition`? I believe there is a table `sla_service_definition` — hmm. Actually, I'm fairly confident the OOB "Service Level Definitions" (like "Availability", "Response time") are stored in `sla_service_definition`? Hmm, hmm. Let me think of the module path: "Service Level Management > Definitions" — table `sla_definition`? That's for traditional SLAs. For CSDM commitments, targets reference "Service Level Definitions" — I believe the table is `sla_service_definition`. Hmm, I've seen `sla_service_definition` somewhere... Actually yes: I recall `sla_service_definition` is the table for Service Level Definitions in CSDM (fields: display name, metric type e.g. Availability/Response time, unit). And `sla_service_level_target` has fields: service commitment, service level definition, target value (e.g., 99.9), unit, threshold, severity. Hmm, wait — does target have "unit"? I think the unit comes from the definition. I'll present with reasonable confidence but can add a note that exact table names should be verified per release. Actually, better to state them as I best recall; the user asked for a data model "auf Basis des Servicenow CSDM 5 Modells" — precision matters but minor table-name differences are acceptable if I flag it. **Operate Value Stream:** - CIs: cmdb_ci_server, cmdb_ci_database, cmdb_ci_appl, cmdb_ci_vm_instance, cmdb_ci_cloud_service_account, cmdb_ci_endpoint, etc. - Dynamic CI Group: `cmdb_ci_dyn_group`? Hmm. I recall the DCG table is `cmdb_ci_dyn_group`. Let me double check mentally: Dynamic CI Group [cmdb_ci_dyn_group]? I've also seen "u_dynamic_ci_group"? No, that's customer-created. I'm fairly confident it's `cmdb_ci_dyn_group`. Hmm, actually I think it's `cmdb_ci_dyn_group` — yes. Wait, I want to double-check: ServiceNow Dynamic CI Groups table name. The class label is "Dynamic CI Group" and name... I believe `cmdb_ci_dyn_group`. Yes. **ITSM connections:** - Incident: `incident` — fields: service offering (service_offering), service (service table?), configuration item (cmdb_ci), service commitment is auto-derived from offering + priority → commitment-based SLAs (sla_service_commitment) drive Incident SLAs now. In newer releases, task SLAs can attach based on service commitments. - Problem: `problem` — CI, service offering - Change Request: `change_request` — CI (affected), service offering - Request Item: `sc_req_item` — service offering from catalog item - Task SLA: `task_sla` — linked to incident/problem etc. - SLA definitions (traditional): `sla` — but CSDM approach uses service commitments. **Key relationships (cmdb_rel_type):** - Application Service → Business Application: "Supports::Supported by" (App Service supports Business App). Direction: Application Service "Supports" Business Application; Business Application is "Supported by" Application Service. - Service Offering → Application Service: "Is deployed as::Deployed version of"? Hmm — direction: Application Service "Is deployed as" Service Offering? Let me get this right. CSDM: Service Offering is the sellable/contractual thing; Application Service is the operational realization. The relationship type: "Is deployed as::Deployed version of" — I recall Service Offering "Is deployed as" Application Service? Or Application Service "Is deployed as" Service Offering? Hmm. From ServiceNow docs: "Service Offering [service_offering] Is deployed as::Deployed version of Application Service"? Hmm... Actually I recall it's the Application Service that "Is deployed as" the Service Offering? That seems backwards. Let me think semantically: The Application Service is deployed AS a Service Offering? No wait — "Is deployed as" makes sense from Service Offering perspective? Hmm: "The Service Offering is deployed as an Application Service"? That reads: Offering → deployed as → App Service. Hmm, but "Deployed version of" — the Application Service is a "deployed version of" the Service Offering? That reads App Service → deployed version of → Offering. The pair "Is deployed as::Deployed version of" is a single relationship type with two directions. If we say "Service Offering Is deployed as Application Service", then Application Service is "Deployed version of" Service Offering. Hmm, semantically: an Application Service instance is a deployed version of a Service Offering? That seems odd — more natural: The Application Service (technical runtime) is deployed AS the Service Offering (the customer-facing realization)? Hmm. I recall from CSDM docs: "Service Offering → Application Service: Is deployed as::Deployed version of"? Let me try to recall the doc table: CSDM recommended relationships: - Application Service → Business Application: "Supports::Supported by"? Hmm wait, direction: I believe it's Application Service "Supports" Business Application. Yes. - Service Offering → Application Service: "Is deployed as::Deployed version of" with Service Offering on the "Is deployed as" side? Hmm, I genuinely recall the docs phrase: "Service Offering Is deployed as Application Service"? Hmm, that doesn't parse well. Alternatively "Application Service Is deployed as Service Offering"? Let me think about it from the relationship type definition: "Is deployed as / Deployed version of". If A "Is deployed as" B, then B is the "Deployed version of" A? No — relationship types in ServiceNow define: Type "Is deployed as" suggests the child is deployed as the parent? E.g., "cmdb_ci_linux_server Runs on cmdb_ci_win_server"? Bad example. Consider "Is deployed as::Deployed version of" typical usage: In Software Model → "Is deployed as" → Application Service? Hmm. Alternative approach: state it as: Service Offering —"Is deployed as"→ Application Service (i.e., the offering is realized/deployed by the Application Service; reverse: Application Service is "Deployed version of" the Offering). Hmm, "Deployed version of" from App Service to Offering... "This Application Service is a deployed version of this Service Offering"? Hmm, that could make sense: multiple app services could be deployed versions of one offering? Eh. Actually, I now recall more specifically from ServiceNow CSDM documentation (v3 and v4): the recommended relationship is: "Service Offering — Is deployed as → Application Service" — hmm no wait. Let me recall the CSDM v3 whitepaper table "Recommended relationships": - Business Application — Runs on → Application Service? No... - Application Service — Supports → Business Application - Service Offering — Is deployed as → Application Service? Hmm... Hmm, I found in memory: "Application Service [cmdb_ci_service] Is deployed as::Deployed version of Service Offering [service_offering]"? Honestly, I've seen both phrasings in community posts. Let me reason about the relationship type definition in ServiceNow OOB: The suggested relationship "Is deployed as::Deployed version of" is defined between... hmm. In OOB CMDB rel type definitions: "Is deployed as::Deployed version of" exists and is suggested for pairs like "Application Service → Software Instance"? Hmm no. OK here's another angle: ServiceNow documentation "CSDM 4.0: Service Offering and Application Service relationship" — I recall a diagram: Service Offering ← "Is deployed as" — Application Service? The arrows in the CSDM diagrams: Business Application → Application Service (Supported by?), Application Service → Service Offering? In CSDM docs, the "Design" value stream diagram shows: Application Service —(Is deployed as)— Service Offering, where the arrow labeled "Is deployed as" points from Service Offering to Application Service? I genuinely can't pin the direction from memory with certainty. Let me think about semantics one more time. In English: "X is deployed as Y" means X gets deployed in the form of Y. "Y is a deployed version of X" means Y is an instance/deployment derived from X. So if Service Offering "is deployed as" Application Service, then Application Service is "deployed version of" Service Offering. Meaning: the offering gets deployed as an app service; the app service is a deployed version of the offering. Semantically: an Application Service is the deployed/operational version of a Service Offering. That matches CSDM intent: The Application Service is the operational representation deployed in the environment realizing the Service Offering. Hmm, but actually CSDM says the opposite: Service Offering is the customer-facing contract for the Application Service; the Application Service is deployed in the environment. "The application service is deployed as part of delivering the service offering." Community consensus (I recall ServiceNow community posts and the CSDM whitepaper): "Service Offering → Application Service: Is deployed as::Deployed version of" where Service Offering is the parent in "Is deployed as" direction? Hmm... Actually — I now recall the CSDM v4 diagram more concretely: In the "Design Value Stream" diagram, there's a line between "Service Offering" and "Application Service" labeled "Is deployed as" with the arrow from Service Offering pointing to Application Service? And I recall the doc text: "Service Offering: ...relate the Service Offering to the Application Service it is deployed as." Hmm, that phrasing suggests Service Offering "Is deployed as" Application Service. Wait, that's weird semantically but it matches "the offering is deployed as the app service". Hmm, alternatively the doc says: "Application Service: relates to Service Offering it is deployed as"? Let me try yet another angle: ServiceNow product docs "Create a relationship between a service offering and an application service" — I believe the instruction: "On the Service Offering form, in the Deployed as related list..."? Hmm. There IS a related list on service_offering called "Deployed as"? If the related list on Service Offering shows "Deployed as" records, then Service Offering "Is deployed as" Application Service. Hmm, I think I recall related lists: On service_offering: "Application Services" or "Deployed as". I'll go with: Service Offering —"Is deployed as"→ Application Service (reverse: Application Service —"Deployed version of"→ Service Offering). I'm moderately confident this is the OOB suggested direction per CSDM. Hmm wait, actually now I remember a ServiceNow doc snippet: "An Application Service is deployed as a Service Offering"? No... Ugh. Let me just present it neutrally: "Service Offering ↔ Application Service via 'Is deployed as / Deployed version of'" and describe: the Application Service is the operational realization (deployed version) of the Service Offering. That conveys the semantics without risking the direction error. Actually, I can write: "Service Offering –[Is deployed as]– Application Service" and note that the Application Service represents the deployed realization. To be safe, I'll phrase: "Beziehung: Is deployed as (Service Offering ↔ Application Service): verbindet das angebotene Service Offering mit der operationalen Realisierung (Application Service)." Hmm, but for a data model, direction matters. Let me make a final decision: I'm going to state it as the ServiceNow docs do. Let me really dig: CSDM 4.0 documentation, "Recommended relationships for the Design value stream": - "Business Application: Related lists... Application Services (Supported by::Supports?)" - I recall: "Application Service Supports Business Application" — direction: Application Service → Business Application with "Supports"; reverse "Supported by". For Service Offering ↔ Application Service, I now genuinely recall the doc: "Service Offering – Is deployed as – Application Service" where the Service Offering "Is deployed as" the Application Service. Hmm wait, no. I recall the CSDM v4 docs table for service_offering: "Related lists: Application Services (Is deployed as::Deployed version of)"? Hmm, hmm. OK here's a cleaner memory: The CSDM whitepaper has a table "Relationships between service_offering and application services": "Service Offering — Is deployed as::Deployed version of — Application Service". In ServiceNow relationship tables, the format is "Parent — type — Child". So Parent=Service Offering, relationship type "Is deployed as", Child=Application Service. And the reverse type shown is "Deployed version of". So: Service Offering "Is deployed as" Application Service; Application Service is "Deployed version of" Service Offering. Semantically: The offering is deployed as (realized by) the app service; the app service is the deployed version of the offering. That's consistent with my earlier semantic analysis. I'll go with that. Wait, but hold on — semantically "Application Service is a deployed version of Service Offering" is a bit odd because offerings are sold to consumers and app services are operational. But "deployed version of" from App Service → Offering can be read as: this operational thing is the deployed version of what we sell. Yeah OK. Hmm, but actually I want to double check with another known example: In the "Operate" stream, "Application Service Is deployed as ... "? No. There's also the "Runs on::Runs" between Application Service and Server: Application Service "Runs on" Server; Server "Runs" Application Service. Yes, that's standard. - Application Service → Technical Service: Application Service "Supports::Supported by" Technical Service? I recall Technical Services relate to Application Services via "Supports::Supported by" (Technical Service supports Application Service). Yes: "Technical Service Supports Application Service". Hmm, or is it the other way? CSDM v4: Technical Services support Business Applications and/or Application Services. The relationship: "Application Service — Supported by — Technical Service"? I recall: "Technical Service [cmdb_ci_service_technical] Supports::Supported by Application Service". Direction: Technical Service "Supports" Application Service. Yes, I'll go with that. - Technical Service → Technical Service (parent/child): "Contains::Contained by"? Or "Depends on::Used by"? For decomposing technical services. I recall "Contains::Contained by" for parent-child technical services? Hmm, not sure. Could use "Depends on::Used by". I'll mention composition via "Contains::Contained by" cautiously or just say child technical services can be related via e.g. "Contains::Contained by" or "Depends on::Used by". - Application Service → Server: "Runs on::Runs" (App Service runs on server). - Application Service → Database: "Contains::Contained by" (App Service contains database). Yes, CSDM: database instances are "Contained by" application services. Actually direction: Application Service "Contains" Database. Yes. - Application Service → Network gear: "Contains::Contained by"? Hmm. For network devices I recall "Runs on::Runs"? For an app service and a load balancer: App Service "Runs on" load balancer? Hmm. Common guidance: Application Service "Contains::Contained by" for network devices (switches, routers, firewalls) — I think that's right in CSDM v4. Actually hmm, for network gear Discovery creates "Connected by::Connects to" relationships between devices. For App Service → netgear, CSDM recommended: "Contains::Contained by"? I believe yes: Application Service contains network gear. Let me also recall: "IP Switch — Connected by — Application Service"? Hmm no. From CSDM docs (recommended relationships for application services): - Application Service "Runs on::Runs" Server? Wait, actually I recall it's the reverse phrasing: "Application Service — Runs on — Server"? "Runs on::Runs": App Service Runs on Server; Server Runs App Service. Yes. - Application Service "Contains::Contained by" Database - Application Service "Contains::Contained by" Network gear (cmdb_ci_netgear)? I believe yes. - Application Service "Depends on::Used by" Application Service (service dependencies between app services). - Application Service "Hosted in::Hosts"? No — "Application Service is hosted on..."? Datacenter: Server "Hosted in::Hosts"? Hmm, actually datacenter relationship: CIs are located in datacenter via "Hosted in::Hosts"? For datacenter: "cmdb_ci_datacenter Hosts::Hosted in ..." Hmm: The relationship type is "Hosted in::Hosts". E.g., Server — Hosted in — Datacenter? The suggested type name "Hosted in" describes the CI being hosted in the datacenter. Hmm, but I recall in ServiceNow, Datacenter class has "Contains::Contained by" for... Actually: "Datacenter — Contains — Server"? I recall Discovery creates "Hosted in::Hosts"? Hmm. For rooms: "Hosted in::Hosts" is for datacenter > datacenter hall? no... Let me simplify: For the data model sample, I'll show: Server —"Hosted in"→ Datacenter? Hmm, hmm. Actually I'm now fairly sure: The OOB suggested relationship for Datacenter: "Datacenter Hosts::Hosted in Server"? No no. Let me think: The relationship type "Hosts::Hosted in" — e.g., "Windows Server Hosted in Datacenter"? The phrase "X is hosted in Y". In ServiceNow CMDB, the relationship type is "Hosted in::Hosts" where e.g. "Application Server Hosted in Host"? Hmm! Yes! That's it: "Hosted in::Hosts" is used for CI → Host (e.g., an application hosted in a host computer). And for datacenters, Discovery creates "Hosted in::Hosts"? Hmm, no — for datacenter: I recall "Datacenter — Contains — ..."? Hmm, actually I remember now: In ServiceNow CMDB, datacenters contain buildings/rooms? No — Datacenter class (cmdb_ci_datacenter) has suggested relationship "Contains::Contained by" with servers? Hmm. I recall Discovery populates "Server — Hosted in — Datacenter"? Hmm... Honestly, I think for datacenters the common relationship is: "Server Hosted in Datacenter"? Hmm, but hmm. Actually, I'm now recalling the CMDB relationship suggestion list: Datacenter (cmdb_ci_datacenter) "Hosts::Hosted in" — used where datacenter is parent? "Datacenter Hosts Server"? Hmm that doesn't sound right either. I'll avoid over-specifying datacenter relationships; sample data can note location attribute on servers (datacenter field on server CI) rather than a relationship. Good compromise: mention "Standort via 'Hosted in::Hosts' bzw. Location-Feld" with a caution. Hmm, but I think I should just keep location simple: servers have a "datacenter" reference field? Servers have "location" field. Datacenter can be linked via relationship. I'll mention "Hosted in::Hosts" as the typical datacenter relationship — I believe this is indeed the OOB suggested type for Datacenter→Computer? Hmm, hmm. Actually, let me recall the exact OOB suggested relationships for cmdb_ci_datacenter: In the "Suggested Relationships" for Datacenter: "Datacenter — Contains::Contained by — ..." hmm no. I remember "Hosted in::Hosts" is heavily used by Discovery for physical containment: e.g., "Rack — Hosts — Server"? Hmm no, racks: "Server Hosted in Rack"? OK, decision: I'll use "Hosted in::Hosts" for Server→Datacenter in the sample and it's defensible; many CSDM docs show "Hosted in" for datacenter. Hmm, wait, I actually now recall the CSDM whitepaper "Physical datacenter containment": Datacenter → Datacenter Hall? no... Let me just include: "Server — Hosted in → Datacenter" (via Hosted in::Hosts) and note it can also be modeled via Location. Fine. - Service Offering → Business Application? Hmm, CSDM: Business Applications are supported by Application Services; Service Offerings deployed as Application Services. Also Business Application relates to Service Offering? Not directly — transitive via Application Service. OK. - Service Portfolio ↔ Service: "Contains::Contained by"? For Service Portfolio and Service: I believe portfolio contains services via... hmm, the `service` table has a field "portfolio"? In CSDM v4, Service records have a "Service portfolio" field? And Service Offerings belong to a Service (field "service" on service_offering). Service Catalogs contain Service Offerings (field or m2m). I recall `service_offering` has "parent" field? In CSDM v4, offerings can be nested (child offerings) via "parent" field. And "service" field linking offering → Service. Yes: service_offering.service → service. And service.portfolio? I think Service has a portfolio field? Hmm, or portfolios contain offerings? In CSDM v4: "Service Portfolio contains Services"? I believe the Service table has a "Portfolio" reference field. And Service Catalog: offerings are added to catalogs — there's a related list or the catalog record with... I recall `service_catalog`? Hmm, hmm. CSDM v4 introduced "Service Catalog" as a new table? I'm not 100% sure of the table name. Hmm. I think in CSDM v4, the Sell/Consume "Service Catalog" entity exists for grouping offerings per consumer type. Table might be `service_catalog`? Hmm — but there's already `sc_catalog` for the classic Service Catalog. The CSDM one... I genuinely am unsure. I'll mention it cautiously as "Service Catalog (neu in CSDM v4/5)" without insisting on exact table name, or use `service_catalog` with a caveat. Hmm, risky. Let me think: I recall the CSDM 4.0 release notes: "Service Catalog: a new table [service_catalog]..."? I do have a vague memory of `service_catalog` table in the CSDM context. Hmm, I also recall "Service Catalog records store... offerings associated..." I'll mention it briefly with "(CSDM v4: service_catalog)" and a note to verify. Actually, to minimize risk, I'll mention the concept without table name, or say "Service Catalog (Tabellenname: service_catalog in neueren Releases; prüfen)". Hmm — providing possibly-wrong names with a verification note is acceptable for a consulting-style deliverable? The user asked to create a data model — a best-effort with a disclaimer is reasonable. But I should minimize disclaimers and be confident where I'm confident. Let me now recall CSDM 5.0 specifically. CSDM 5.0 was announced/released around 2024 (with Washington/Xanadu releases?). Key changes in CSDM 5.0 vs 4.0: Hmm. My knowledge: CSDM 4.0 (Vancouver-era), CSDM 5.0 (late 2024?). Changes in 5.0: I recall CSDM 5.0 added... hmm. Honestly, my knowledge of CSDM 5 specifics is thin. Known: CSDM versions 1.0 (2019), 2.0 (2020), 3.0 (2021), 3.1, 4.0 (2023), 5.0 (2024/2025?). CSDM 5.0 changes I vaguely recall: introduction of "Technical Service Offerings"? Hmm! Yes — I think CSDM 5.0 introduced "Technical Service Offering" as a new concept/table? Hmm. Let me think... I recall discussions about CSDM 5.0 adding "Technical Service Offerings" to bridge Technical Services and offerings, and maybe "Service Groups"? Hmm. I genuinely recall: CSDM 5.0 (released ~2024) — main additions: - "Technical Service Offering" table? - Changes to "Service" table? - Maybe "Consumer" concept expansions? Hmm. I'm not confident about CSDM 5.0-specific deltas. Best approach: build the model on the CSDM structure that is stable across 4/5 (Design, Sell/Consume, Operate) and note CSDM 5.0 specifics where I'm reasonably sure, with a general note that CSDM 5.0 extends CSDM 4.0 and details should be checked against the official CSDM guidance (now part of ServiceNow docs under "Common Service Data Model"). Actually, I recall CSDM guidance moved to the ServiceNow product documentation, and CSDM 5.0 aligns with the "Xanadu" release. Some things I half-remember about CSDM 5.0: - "Technical Service Offerings" (new class for offerings of technical services, for internal/technical catalogs) - Possibly "Service Instance"? no... - "Application Service" remains. - Maybe deprecation of "Service Subscription"? no, subscriptions continue. Hmm, I also recall CSDM 5.0 might have introduced the "Service Catalog" concept and renamed stuff. Honestly, the safest: present the model generically per CSDM 4/5 with the entities: Service Portfolio, Service, Service Offering, (Technical) Service Offering?, Application Service, Technical Service, Business Application, Service Catalog, Subscriptions, Commitments (SLA/OLA/UC), Service Level Definitions/Targets, CIs, DCGs; and ITSM task integration. I'll add a short "CSDM 5.0 Hinweise" box noting: CSDM 5.0 baut auf 4.0 auf; neue Tabelle für Technical Service Offerings (`cmdb_ci_service_technical_offering`? hmm — no idea). Hmm wait — actually I do now recall something concrete: CSDM 5.0 introduced "Technical Service Offering" as a subclass related to Technical Services, enabling selling technical services internally. The table... could be `cmdb_ci_service_technical_offering`? Or is the technical offering stored in `service_offering` with a type? Hmm. There's a field "offering type"? Hmm. Alternatively maybe CSDM 5.0's headline was "Service Groups"? Hmm no. Let me search memory differently: ServiceNow CSDM 5.0 announcement (2024): "CSDM v5.0 introduces... a new data model for Technical Services and Technical Service Offerings... enables managing services for technical consumers... 'Internal Service Offerings'?" I genuinely recall "Technical Service Offering" being new in CSDM 5.0. I also recall CSDM 5.0 possibly renaming "Application Service" to keep as-is, and adding "Dynamic CI Group" integration. Given uncertainty, I'll structure the deliverable as: 1. **Kurzeinordnung CSDM 5** — three value streams, domains (Design, Sell/Consume, Operate), note that CSDM 5 continues/extends CSDM 4. 2. **Entitäten & Tabellen (Kernmodell)** — table listing: Entity, Table, Key fields, Purpose. 3. **Beispieldaten** — a coherent German example scenario: Company "Nordwind Bank" or generic "ACME GmbH" with: - Service Portfolio: "IT-Servicekatalog Unternehmen" - Services: "Arbeitsplatz", "Business Applications", "Infrastruktur & Netzwerk"? In CSDM v4, "Service" groups offerings; sample: Service "Arbeitsplatz-Service" containing offerings "Standard-Arbeitsplatz", "Premium-Arbeitsplatz"; Service "Business Application Services" containing "SAP-Betrieb", "E-Mail & Collaboration"... - Service Offerings: "E-Mail & Collaboration (Standard)", "E-Mail & Collaboration (Premium)"; "SAP ERP Betrieb" - Business Applications: "SAP ECC", "Microsoft 365", "Intranet Portal" - Application Services: "AS SAP ECC PRD", "AS Exchange Online", "AS SharePoint Online" - Technical Services: "Rechenzentrum Hosting", "Netzwerkdienste", "Microsoft 365 Tenant Management" - CIs: Servers (sapdb01, sapapp01), VMs, Database (SAP HANA PRD), network gear, endpoints - Subscriptions: Internal Business Unit "HR" subscribes to "E-Mail Standard" offering; external customer? Keep internal. - Commitments: SLA "E-Mail Standard SLA" (Service commitment, type SLA, attached to offering), OLA "Datacenter Operations OLA" (type OLA, attached to Technical Service or its offering?), UC "Microsoft Unified Support" (type UC). In CSDM, commitments attach to Service Offerings (and CSDM 5 may allow on technical service offerings). Targets: Availability 99.9%, Incident response P1 15 min, resolution P2 8h etc. - Service Level Definitions: "Availability", "Incident Response Time", "Incident Resolution Time", "Change lead time"? - Incidents: 2-3 sample incidents referencing offering + CI, with priority mapping to commitments → resulting SLAs (task_sla) with breach times. - Problem, Change samples briefly. 4. **Beziehungsübersicht** — matrix: Relationship type, Parent→Child direction, example, purpose. Include cmdb_rel_ci types: Supports/Supported by, Is deployed as/Deployed version of, Runs on/Runs, Contains/Contained by, Depends on/Used by, Hosted in/Hosts, Consumes/Consumed by? (Business Application consumes Application Service? no). Also Service Offering ↔ Application Service; Application Service ↔ DCG? DCG "Contains" CIs via query — the DCG relates to Application Service? Hmm: Dynamic CI Groups: you can create an Application Service from a DCG. The DCG itself holds the query. Relationship DCG → Application Service? I don't recall a standard relationship; the app service is just populated. Keep it simple: mention DCG as mechanism. 5. **ITSM-Integration (Task-Tabellen)** — Incident/Problem/Change/RITM reference Service Offering + CI; commitments drive SLAs; maybe a small flow. 6. **Modell-Diagramm** — Mermaid ER diagram or ASCII. Mermaid `erDiagram` is nice and renders in many contexts; but ASCII is safe. I could do both? Maybe one clean Mermaid ER diagram + relationship list. The formatting guidance: use markdown, code blocks for diagrams. A Mermaid diagram could be valuable. I'll include one Mermaid ER diagram (entities + relations) and maybe a small Mermaid flow for incident→SLA resolution. Keep diagrams compact. 7. **Praxis-Hinweise**: Fallback, minimal viable CSDM, data certification, DCG vs Discovery, roles. Sample data should be realistic and consistent. Let me design the scenario: "Musterbank AG" IT. Actually simpler: "ACME Industrie AG" with IT organization. **Sample data plan:** Service Portfolio: `IT-Porträt...` — "Unternehmens-IT-Portfolio" (service_portfolio) Service (service table): - SVC001 "Arbeitsplatz & Collaboration" - SVC002 "Business Applications" - SVC003 "Infrastruktur & Netzwerk" Service Offerings (service_offering): - OFF001 "E-Mail & Collaboration – Standard" (Service: Arbeitsplatz & Collaboration; catalog: Interner Mitarbeiterkatalog) - OFF002 "E-Mail & Collaboration – Premium" (add-ons, longer features) - OFF003 "SAP ERP – Betriebservice" (Service: Business Applications) - OFF004 "Netzwerkdienste – Standortbetrieb"? maybe technical offering instead. Business Applications (apm_application): - BApp001 "Microsoft 365 Tenant" - BApp002 "SAP ECC (Finanz & Logistik)" - BApp003 "Intranet Portal" Application Services (cmdb_ci_service_discovered): - AS001 "AS Exchange Online" (supports BApp001) - AS002 "AS SharePoint Online" - AS003 "AS SAP ECC Produktion" (supports BApp002) - AS004 "AS SAP ECC Test" (supports BApp002) Technical Services (cmdb_ci_service_technical): - TS001 "Microsoft 365 Tenant-Betrieb" (supports AS001, AS002) - TS002 "SAP Hosting Rechenzentrum" (supports AS003) - TS003 "Netzwerkdienste" (supports AS003, AS004 etc.) Deployed as: OFF001 —Is deployed as→ AS001 (und AS002? one offering can map to multiple app services? Better 1:1 for clarity: OFF001 → AS001; maybe note 1:n allowed). OFF003 → AS003. CIs: - Server: SRV001 "sapapp01" (Linux, hosted in DC1 Frankfurt), SRV002 "sapdb01" (HANA) - Database: DB001 "SAP HANA PRD" (contained by AS003, runs on SRV002) - VM: VM001 "sapapp01 (vm)"? keep servers only to reduce clutter. - Network: NET001 "FW-FRA-01" firewall (contained by AS003) - Cloud: CSP001 "Microsoft 365 Subscription" (cloud service account) maybe. Subscriptions (service_subscription): - SUB001: Consumer = Department "Personalabteilung (HR)", offering OFF001, 350 users - SUB002: Consumer = Department "Finanzbuchhaltung", offering OFF003, 45 users - SUB003: Consumer = "Vertrieb", OFF002, 120 users Service Commitments (sla_service_commitment): - SLA-C001 "SLA E-Mail Standard" (type SLA, offering OFF001, schedule 24x7, timezone Europe/Berlin) - SLA-C002 "SLA SAP ERP Betrieb" (type SLA, offering OFF003, business hours 24/7? For SAP PRD: 24x7) - OLA-C001 "OLA Rechenzentrum Hosting" (type OLA, attached to OFF003 or technical service TS002; supports back-to-back) - UC-C001 "UC Microsoft Premier Support" (type UC, offering? attached to TS001/OFF001 as underpinning contract with Microsoft) Service Level Targets (sla_service_level_target): - For SLA-C001: Availability ≥ 99.9 %/month; Incident response P1 ≤ 15 min; Incident resolution P1 ≤ 4 h; P2 response ≤ 30 min... - For SLA-C002: Availability ≥ 99.5 %; P1 resolution ≤ 2 h (SAP PRD) - OLA targets: Availability ≥ 99.95, response 5 min - UC targets: Microsoft response time per severity. Service Level Definitions (sla_service_definition): "Availability", "Response Time", "Resolution Time" with units %, minutes. Incidents (incident): - INC0010001: "Outlook-Anmeldung nicht möglich" — offering OFF001, CI AS001, priority P2/High; SLA from commitment SLA-C001 (task_sla: response 30 min met; resolution 8h due...) - INC0010002: "SAP-Transaktion FB01 Timeout" — offering OFF003, CI AS003 (or DB001), priority P1/Critical; SLA-C002 → resolution 2h; linked problem PRB0040001 root cause DB001. - INC0010003: "Druckqueue Standort Hamburg" — CI printer? keep 2 incidents maybe + 1. Problem: PRB0040001 "HANA-Performance-Degradation" — CI DB001, related incidents. Change: CHG0030001 "HANA-Parameter-Anpassung" — CI DB001, service offering OFF003. Task SLAs (task_sla): derived from commitments: INC0010002 has task_sla "SAP Resolution P1 – 2h" breach_at timestamp. Also mapping priority→commitment: The commitment has "priority mapping"? In ServiceNow, service commitments + service level targets map via task SLA definitions generated ("Commitment rules")? There's a feature where Service Commitments generate Task SLAs based on priority mapping (field "priority" on target?). I recall Service Level Targets can have "task priority" mapping? There's the "Commitment" → auto-generated SLA definitions feature ("sla_service_commitment" creates "SLA definitions" per priority?). I recall in recent releases, "Service Commitments" can automatically create Task SLAs by mapping commitments' targets to task priorities via "Service level targets" with "Task type" and "Priority"? Hmm. There's a feature "Commitment-based SLAs" where you define "Commitment targets" and they're attached to tasks matching service offering + priority. I'll describe generically: "Bei Ticketerfassung (Incident mit Service Offering + Priorität) ermittelt die Plattform die passenden Commitments/Targets und hängt Task-SLAs an (task_sla)." Relationship overview table — list with direction and example: | Von (Parent) | Beziehungstyp (cmdb_rel_type) | Zu (Child) | Beispiel | Zweck | 1. Service Offering — Is deployed as / Deployed version of — Application Service — OFF001 → AS001 2. Application Service — Supports / Supported by — Business Application — AS003 → BApp002 3. Technical Service — Supports / Supported by — Application Service — TS001 → AS001 4. Application Service — Runs on / Runs — Server — AS003 → SRV001 5. Application Service — Contains / Contained by — Database — AS003 → DB001 6. Application Service — Contains / Contained by — Netzwerk (Firewall/Switch) — AS003 → NET001 7. Application Service — Depends on / Used by — Application Service — AS003 → AS? e.g., AS003 depends on AS "AD Authentication"? add AS005 "AS Active Directory" — AS003 → Depends on → AS005. Good, adds dependency example. 8. Server — Hosted in / Hosts — Datacenter — SRV001 → DC001 9. Database — Runs on / Runs — Server — DB001 → SRV002 (DB runs on server) 10. Service (service) — Contains? / offerings: Service Offering field "Service" (reference, not CMDB relationship) — OFF001.service → SVC001 11. Service Portfolio ↔ Service: reference field (portfolio) — SVC001.portfolio → Portfolio 12. Service Offering ↔ Service Catalog: reference/m2m — OFF001.catalog 13. Service Subscription: offering + consumer (no CMDB rel) 14. Service Commitment: offering reference (+ technical service for OLA/UC?) 15. Incident: service_offering field, cmdb_ci field 16. Problem/Change: cmdb_ci, service_offering 17. Task SLA: task + sla (generated from commitments) Also Business Application ↔ Application Service direction: "Application Service Supports Business Application" (App Service → Business App, type Supports). Wait, which is parent? In ServiceNow suggested relationships: "Business Application — Supported by — Application Service"? Hmm. The doc: "Application Service [cmdb_ci_service] Supports::Supported by Business Application [cmdb_ci_business_app]"? Hmm hmm. I recall the CSDM docs: "Business Application: ... create relationship 'Runs on' or 'Supported by' to Application Service"? Common community practice: Business Application "Runs on::Runs" Application Service? No... CSDM v3 recommended: "Application Service — Supports — Business Application". Yes, I'm fairly confident. In the CSDM whitepaper v3: "Application Service → Business Application: Supports::Supported by (Application Service supports the Business Application)". Good. Also, Business Applications relate to Application Services that support them; sometimes multiple. Also "Service Offering" → "Business Application"? Not standard; skip. Consumers: In CSDM, "Consumer" (Account/Department/Company) for subscriptions; service_subscription fields: "service offering", "consumer" (account/department/company), maybe "quantity". Keep it. Now the Mermaid ER diagram. Mermaid erDiagram syntax: ```mermaid erDiagram SERVICE_PORTFOLIO ||--o{ SERVICE : enthaelt SERVICE ||--o{ SERVICE_OFFERING : gruppiert SERVICE_OFFERING ||--o{ SERVICE_SUBSCRIPTION : wird_abonniert_via ... ``` But Mermaid ER with many entities gets long. Alternatively use a Mermaid flowchart (graph) with subgraphs for Design/Sell/Operate. A flowchart might be clearer for relationships (directed). Let me draft: ```mermaid graph TB subgraph Design["Design Value Stream"] PORT[Service Portfolio] SVC[Service] OFF[Service Offering] CATALOG[Service Catalog] BAPP[Business Application] AS[Application Service] TS[Technical Service] end ... ``` Might get messy with edge labels. Alternatively ASCII diagram. I think one Mermaid `graph` with labeled edges is good, plus the relationship table. Let me keep the diagram focused: Portfolio → Service → Offering; Offering → deployed as → App Service; App Service → supports → Business App; Tech Service → supports → App Service; App Service → runs on/contains → CIs; Offering ← Subscription ← Consumer; Offering ← Commitment (SLA/OLA/UC) → Targets → Definitions; Incident/Problem/Change → Offering/CI; Task SLA from commitments. Maybe two diagrams: (1) CSDM core (Design + Sell/Consume), (2) Operate + ITSM integration. Or one combined. I'll do one main Mermaid diagram with subgraphs, and possibly a second small one for the Incident→SLA flow. Keep it manageable. Format considerations: The response should be in German, well-structured with headers, tables, code blocks for Mermaid and maybe sample records in JSON-ish or table form. Length: This is a substantive deliverable request — a comprehensive answer is appropriate. But I shouldn't overdo it; aim for a thorough but scannable document. Use tables for sample data (compact). Use code blocks for Mermaid diagrams and maybe table names. Let me draft the content: # Datenmodell ITSM auf Basis von CSDM 5 (ServiceNow) ## 1. Grundstruktur (CSDM 5) - Drei Value Streams: Design, Sell/Consume, Operate; zwei Domänen-Sichten: Business (Services & Offerings), Technical (Application/Technical Services, CIs). - CSDM 5 baut auf CSDM 4 auf (Design/Sell/Consume/Operate bleiben; Technical Services und Service als eigene Objekte, Subscriptions, Commitments). Actually, CSDM v4 introduced: Service & Service Offering separation, Technical Services, Subscriptions became first-class, commitments... CSDM v3 already had commitments? CSDM 3.0 introduced "Service Commitments"? I think Sell/Consume with commitments existed in v3. CSDM 4.0 added: Technical Services, "Service" table, Service Catalog, renamed cmdb_ci_service → cmdb_ci_service_discovered, Business Application → apm_application, subscriptions enhancements. CSDM 5.0 — I'll say it "verfeinert" these, ohne spezifische Claims. Maybe mention: "CSDM 5.0 ist eine Weiterentwicklung; Kernentitäten und -beziehungen wie unten." I should avoid fabricating CSDM 5 specifics. I could add one line: "Hinweis: CSDM 5.0 ergänzt v. a. Details im Design-Bereich (u. a. Technical Service Offerings); die unten dargestellten Kernentitäten gelten für 4.0 und 5.0." Hmm — "Technical Service Offerings" in 5.0 — do I trust that? Moderately. I recall community posts about CSDM 5.0 and technical service offerings... Actually yes, I'm now recalling more strongly: CSDM 5.0's headline feature was indeed "Technical Service Offerings" (offerings for technical services, sellable to internal technical consumers), plus maybe "Service Consumer" enhancements. I'll mention it as a note with hedging ("u. a."). Risk is acceptable with hedging; benefit is showing 5.0 awareness. Hmm, wait. Let me reconsider. Is "Technical Service Offering" really CSDM 5? I have a memory trace of a ServiceNow doc page: "Technical Service Offering [cmdb_ci_service_technical_offering]"? Hmm, or is it in the `service_offering` table with a "type" = Technical? In CSDM 4, `service_offering` has field "offering type"? I don't recall that. There's `service_offering` with fields: service, portfolio? catalog, keywords, status... I also recall CSDM 5.0 introduced "Service Instance"? no. Another possible 5.0 feature: "Consumer Service Scope"? no idea. Given genuine uncertainty, I'll phrase the CSDM 5 note generically: "CSDM 5.0 führt die Struktur von CSDM 4.0 fort (Design, Sell/Consume, Operate) und verfeinert sie (u. a. Technical Services/Technical Service Offerings, Service Catalog). Tabellennamen ggf. releaseabhängig prüfen." That's honest and useful. Hmm, actually, let me reconsider once more... I have some memory of a ServiceNow documentation page "CSDM 5.0" mentioning: "In the CSDM 5.0, Technical Services can have Technical Service Offerings..." Yes, I'm going to include this with soft hedging. Also worth noting: CSDM guidance now lives at ServiceNow docs "Common Service Data Model (CSDM)". ## 2. Kernentitäten & Tabellen Table format: | Wertestrom | Entität | Tabelle (Technischer Name) | Beschreibung/wichtigste Felder | Design: - Service Portfolio — `service_portfolio` — Gruppierung von Services für Steuerung; Felder: title, description, status - Service — `service` — das „Was" aus Produzentensicht; Felder: name, portfolio, status - Service Offering — `service_offering` — das verkaufbare/konsumierbare Angebot; Felder: name, service, catalog?, status, subscription-based flag? (`subscription`?) hmm. Fields: name, service, parent (für Sub-Offerings), description. - Service Catalog — `service_catalog` (CSDM 4+) — Bündelung von Offerings pro Konsumentensicht/Kanal. (hedge) - Business Application — `apm_application` — fachliche Anwendung aus Portfoliomanagement; Felder: name, owner (managed by?), criticality? (`business_criticality`), application manager. - Application Service — `cmdb_ci_service_discovered` — operationaler Dienst in der Umwelt; Felder: name, operational status, environment (prod/test), used_for. - Technical Service — `cmdb_ci_service_technical` — infrastruktur-/technologiebezogener Dienst; Felder: name, service classification (`service_classification` = "Technical Service"). Sell/Consume: - Consumer — `customer_account`/`customer_department`/`consumer`? Subscriptions reference consumer via "consumer" field which can be account (customer_account), department (cmn_department), company (core_company). I recall service_subscription.consumer can point to customer_account / department / company. Also there's a "Consumer" concept in CSDM v4? Hmm, in CSDM v4 docs: "Consumer: the organization or part of it that consumes the service offering... represented by Account [customer_account], Department [cmn_department], or Company [core_company]." Yes, I recall that. - Service Subscription — `service_subscription` — Felder: service offering, consumer, type? quantity? start/end date? (Felder: "service_offering", "consumer_type"? I'll keep generic: consumer, offering, gültig von/bis.) - Service Commitment — `sla_service_commitment` — Vertragliche Zusage (Typ: SLA / OLA / UC); Felder: service offering, commitment type, schedule, timezone. - Service Level Target — `sla_service_level_target` — Zielwert je Metrik; Felder: commitment, service level definition, target value, unit, threshold? priority? — I recall targets have "target" numeric and reference "service level definition". - Service Level Definition — `sla_service_definition`? — Metrik-Katalog (Verfügbarkeit, Reaktionszeit, Lösungszeit); hedge: Tabellenname prüfen. Hmm, let me reconsider the Service Level Definition table. I have decent recall of `sla_service_definition`? Hmm... Searching memory: "Service Level Definitions [sla_service_definition]"? I think I've seen `sla_service_definition` in the ServiceNow docs listing CSDM tables: "Service Commitment [sla_service_commitment], Service Level Target [sla_service_level_target], Service Level Definition [sla_service_definition]". Hmm, plausible pattern. Alternatively "sla_definition" is the classic SLA def table and CSDM reuses? No — classic is `sla`. I'll go with `sla_service_definition` (moderately confident) — hmm, but risk. Alternatively I can write "Service Level Definition (`sla_service_definition`)" — fine. I'll add a footnote that table names per docs may vary slightly by release. Operate: - Konfigurationselemente (CIs): `cmdb_ci_*` — Server `cmdb_ci_server`, Datenbank `cmdb_ci_database`, Netzwerk `cmdb_ci_netgear`, Rechenzentrum `cmdb_ci_datacenter`, VMs `cmdb_ci_vm_instance`, Endpoints `cmdb_ci_endpoint`, Cloud Services `cmdb_ci_cloud_service_account`? (Microsoft 365) — `cmdb_ci_cloud_service_account`? Hmm — there is `cmdb_ci_cloud_service_account`? I recall "Cloud Service Account [cmdb_ci_cloud_service_account]"? Hmm, I think the class is `cmdb_ci_cloud_service_account` — hmm, actually I recall `cmdb_ci_cloud_service_account`? There's "Cloud Service Account" CI class in the cloud stack. I'll keep generic "Cloud-Service (cmdb_ci_cloud_service_account?)" or avoid. Maybe include "cmdb_ci_cloud_service"? Hmm. There is a class "Cloud Service Account"? I'll just skip cloud CI specifics and treat Exchange Online as app service + technical service without a cloud CI, or mention "Cloud-Service-Konto" generically. Keep it minimal. - Dynamic CI Group — `cmdb_ci_dyn_group` — abfragebasierte Gruppen; dient zur automatischen Befüllung von Application Services. ITSM (Operate/consume): - Incident `incident`, Problem `problem`, Change `change_request`, Request `sc_request`/`sc_req_item`, Task SLA `task_sla`, SLA Def `sla` (klassisch). ## 3. Beispieldaten Present as coherent scenario "ACME AG". Use tables: **Design (Business):** Portfolio: | Name | Beschreibung | | Unternehmens-IT-Portfolio | Alle internen IT-Dienstleistungen | Services: | Name | Portfolio | Beschreibung | | Arbeitsplatz & Collaboration | Unternehmens-IT-Portfolio | ... | | Business Applications | ... | | Infrastruktur & Netzwerk | ... | Service Offerings: | Name | Service | Katalog | Status | Abo-Basis | | E-Mail & Collaboration Standard | Arbeitsplatz & Collaboration | Mitarbeiterkatalog | Published | Subscription | | E-Mail & Collaboration Premium | ... | | SAP ERP Betriebservice | Business Applications | Mitarbeiterkatalog? (Business-Unit-Katalog) | Published | Business Applications: | Name | Criticality | Owner | | SAP ECC (Finanz & Logistik) | Mission-critical | M. Weber | | Microsoft 365 Tenant | Business-critical | L. Krause | | Intranet Portal | Moderate | T. Bauer | Application Services: | Name | Klasse | Environment | Unterstützt (Business App) | | AS SAP ECC Produktion | cmdb_ci_service_discovered | Production | SAP ECC | | AS SAP ECC Test | ... | Test? (Dev) | SAP ECC | | AS Exchange Online | ... | Production | Microsoft 365 | | AS SharePoint Online | ... | Production | Microsoft 365 | | AS Active Directory | ... | Production | Microsoft 365? (or Auth service) | Technical Services: | Name | Unterstützt Application Services | | Microsoft 365 Tenant Management | AS Exchange Online, AS SharePoint Online, AS Active Directory | | SAP Hosting Rechenzentrum Frankfurt | AS SAP ECC Produktion, AS SAP ECC Test | | Standortnetzwerk Frankfurt | AS SAP ECC Produktion, AS Exchange Online | **Sell/Consume:** Consumers & Subscriptions: | Subscription | Consumer | Offering | Nutzerzahl | Von–Bis | | SUB0001 | Department Finanzbuchhaltung (120 MA) | SAP ERP Betriebservice | 120 | 01.01.2025– | | SUB0002 | Department Personal (85) | E-Mail & Collab Standard | 85 | | SUB0003 | Department Vertrieb (210) | E-Mail & Collab Premium | 210 | Commitments: | Commitment | Typ | Offering/Service | Zeitplan | Beschreibung | | SLA E-Mail & Collab Standard | SLA | OFF E-Mail Standard | 24×7 | Kundenversprechen | | SLA SAP ERP Betriebservice | SLA | OFF SAP ERP | 24×7 (P1) | ... | | OLA Rechenzentrum Frankfurt | OLA | Technical Service SAP Hosting | 24×7 | Interne Zusage | | UC Microsoft Unified Support | UC | Technical Service M365 Tenant Mgmt | 24×5? | Herstellervertrag | Service Level Targets (je Commitment): | Commitment | Metrik (Definition) | Zielwert | Priorität | | SLA E-Mail Std | Verfügbarkeit | ≥ 99,9 % / Monat | – | | SLA E-Mail Std | Reaktionszeit Incident | ≤ 30 Min | P2 | | SLA E-Mail Std | Lösungszeit Incident | ≤ 8 Std | P2 | | SLA E-Mail Std | Reaktionszeit Incident | ≤ 15 Min | P1 | | SLA SAP ERP | Verfügbarkeit | ≥ 99,5 % / Monat | – | | SLA SAP ERP | Lösungszeit Incident | ≤ 2 Std | P1 | | SLA SAP ERP | Lösungszeit Incident | ≤ 8 Std | P2 | | OLA DC | Verfügbarkeit | ≥ 99,95 % | | UC Microsoft | Reaktionszeit Hersteller | ≤ 60 Min | Sev A | **Operate (CI-Landschaft):** | CI | Klasse | Schlüsselfelder | Beziehungen | | DC-FRA-01 (Rechenzentrum Frankfurt) | cmdb_ci_datacenter | ... | Hosts: sapapp01, sapdb01 | | sapapp01 | cmdb_ci_server (Linux) | IP, OS | Runs: AS SAP ECC PRD; Hosted in DC-FRA-01 | | sapdb01 | cmdb_ci_server | ... | Runs: SAP HANA PRD | | SAP HANA PRD | cmdb_ci_database | Version, Port | Contained by AS SAP ECC PRD; Runs on sapdb01 | | FW-FRA-01 | cmdb_ci_netgear | ... | Contained by AS SAP ECC PRD | | AS Exchange Online | ... contains? M365 cloud: maybe no CIs (SaaS) — good teaching point: SaaS app services often have no contained CIs; supported by technical service. | **ITSM Beispieldaten:** Incidents: | Nr | Kurzbeschreibung | Service Offering | CI | Priorität | Status | Task-SLA (aus Commitment) | | INC0010001 | SAP-Transaktion FB01 Timeout | SAP ERP Betriebservice | AS SAP ECC Produktion (bzw. SAP HANA PRD) | P1 | In Bearbeitung | Lösungszeit P1 ≤ 2 h (Fällig: +2 h) | | INC0010002 | Outlook kann keine Mails senden | E-Mail Standard | AS Exchange Online | P2 | In Bearbeitung | Reaktion ≤ 30 min; Lösung ≤ 8 h | | INC0010003 | Kein Zugriff Intranet Portal | (Offering Intranet?) hmm — I didn't create an offering for intranet. Skip or use printer incident without offering? Better all incidents have offerings. Use INC0010003: "VPN steht Standort Hamburg" — offering? I don't have network offering. Keep 2 incidents + problem + change. Fine. Problem: PRB0040001 "HANA Performance-Degradation nach Patch" — CI SAP HANA PRD; zugeordnete Incidents INC0010001. Change: CHG0030002 "HANA-Parameteranpassung (Standard-Change)" — CI sapdb01 / SAP HANA PRD; Offering SAP ERP Betriebservice. Task SLAs sample: | Task | SLA (generiert aus Commitment) | Start | Fällig | Status | | INC0010001 | SAP ERP – Lösungszeit P1 (2 h) | 14.05.2025 09:12 | 11:12 | In Gefahr? | Maybe simplify: don't overdo timestamps. A couple is fine. ## 4. Beziehungsübersicht Two tables: (a) CMDB-Beziehungen (cmdb_rel_ci) with rel types; (b) Referenzfeld-Beziehungen (Tickets, Subscriptions, Commitments). CMDB rel types: | # | Typ (Parent::Child) | Beispiel | Anmerkung | 1. Service Offering – Is deployed as / Deployed version of – Application Service 2. Application Service – Supports / Supported by – Business Application 3. Technical Service – Supports / Supported by – Application Service 4. Application Service – Runs on / Runs – Server/Host 5. Application Service – Contains / Contained by – Database 6. Application Service – Contains / Contained by – Netzwerkgerät 7. Application Service – Depends on / Used by – Application Service 8. Database – Runs on / Runs – Server 9. Server – Hosted in / Hosts – Datacenter (alternativ Location-Feld) Hmm, regarding #9 — let me reconsider. I'm now fairly sure ServiceNow uses "Hosted in::Hosts"? Hmm, hmm. Actually, you know, I recall CSDM docs: "Datacenter: relate Datacenter to the CIs it contains using 'Contains::Contained by'"? Hmm no... Ugh. Let me think about Discovery: Discovery classifies datacenter? Discovery doesn't create datacenters. Pattern: cmdb_ci_datacenter suggested relationships per ServiceNow docs: "Datacenter -> Contains -> Rack"? Racks contain... hmm. I remember in ServiceNow CMDB: relationship "Hosted in::Hosts" is used e.g. "Windows Server Hosted in ESX Server"? And "Containment: Contains::Contained by" for e.g. "IP Switch Contains Rack"? Hmm. Actually now I recall more specifically: For physical locations in CMDB: Datacenter [cmdb_ci_datacenter] → "Contains::Contained by"? no... I recall the docs "CMDB relationships for datacenters": "cmdb_ci_datacenter Hosts::Hosted in cmdb_ci_server"? Hmm — "Datacenter Hosts Server" — that reads like: the datacenter hosts the server. Hmm, that phrasing is plausible! "Hosts::Hosted in": if datacenter is the parent with type "Hosts", then Server is "Hosted in" datacenter. Hmm, but which direction does OOB define? I think the OOB suggested relationship is: "cmdb_ci_datacenter — Hosts::Hosted in — cmdb_ci_server"? Hmm... I actually believe I've seen "Hosted in" from the server side: "Server Hosted in Datacenter". Wait, but typically the relationship record is created as parent=server? no... In ServiceNow, relationship record has "parent", "type", "child". Display: "parent type child". For "Hosted in::Hosts": if type label is "Hosted in" when read parent→child... The type is one record with two labels: "Hosted in" (forward) and "Hosts" (reverse). If parent=Server, child=Datacenter, reading forward: "Server Hosted in Datacenter" ✓. Reverse: "Datacenter Hosts Server" ✓. Both make sense. So the question is just convention. I recall Discovery creates relationships with parent=CI being hosted, child=hosting element? For "Hosted in::Hosts" the convention I recall from docs: "Application Server — Hosted in — Host computer"? hmm, no: I recall "Hosts::Hosted in" where the HOST is the parent: e.g., "Windows Server Hosts SQL Server"? Hmm! That rings a bell: "Host computer Hosts database"? Hmm no. OK you know what — in the CSDM v3/v4 whitepaper, there IS a specific mention: "Datacenter: The Datacenter CI is related to... using the 'Contains::Contained by' relationship"? I really can't pin it. I'll write it as: Server – "Hosted in" – Datacenter (ggf. zusätzlich Location-Feld). If direction convention is off, the semantics still clear. Alternatively, sidestep: put datacenter relationship in the diagram only. I'll keep it in the table with a soft note "(Standortzuordnung; alternativ über Feld location)". Fine. Additional relations: 10. Service Portfolio – Service: Referenzfeld (nicht CMDB-Rel) 11. Service Offering – Service: Referenzfeld 12. Service Offering – Service Catalog: Referenz 13. Business Application ↔ Application Service — sometimes also "Runs on"? skip. 14. Application Service – Depends on – Technical Service? no, technical supports. Also mention: Service Offering ↔ Service Offering (Parent offering / child offerings via `parent` field) — in CSDM, offerings can have child offerings (for bundling). Optional; mention briefly. (b) Transaktionale Referenzen: | Objekt | Feld | Ziel | Zweck | | Incident | service_offering | Service Offering | Steuerung: Verantwortliches Team, Commitments/SLAs | | Incident | cmdb_ci | CI (z. B. Application Service) | Ursachenanalyse, Impact | | Incident | service | Service (CSDM 4: Referenz auf Service abgeleitet?) hmm — incident has "service" field? In newer releases incident has both "Service" and "Service offering" fields? I recall incident has "Service" (service_offering in older) — Actually: The incident "Service" field historically referenced `cmdb_ci_service` (application service) — no wait. Let me recall: Incident has field "Service" (u_service? no, "service" field referencing service_offering since ~New York "Service offerings in Incident"?). Hmm: In ServiceNow, incident fields: "Service" (`service`) — hmm, there's "service_offering" field added (Jakarta+/Madrid "Service Offering" field) and "cmdb_ci". In recent versions (CSDM v3+), the Incident form shows "Service" (service_offering) and "Service offering"? I think: Field "Service" on incident = `service_offering`? No... Let me recall precisely: Task table has `cmdb_ci`. Incident gained "Service" field? The "Service" field on Incident historically is `cmdb_ci_service` reference? Hmm. In the "Service Centric" incident forms (CSDM v3), Incident has both "Service" (reference to service_offering? no...). I recall: incident.service_offering (reference service_offering) and incident.service (reference... service_offering too? or the `service` table?). Hmm. In CSDM v3, the "Service" field on task = reference to `service_offering`. Then CSDM v4 introduced the `service` table; tasks may also have "Service" → service? I believe in CSDM v4, incident has "Service" field referencing the new `service` table and "Service offering" referencing `service_offering`. Yes — I recall incident form: "Service" and "Service offering" both present in CSDM v4+ forms. OK so I'll list: Incident/Problem/Change: Felder `service` (→ service), `service_offering` (→ service_offering), `cmdb_ci` (→ CI), `business_service`? (legacy). Good. | Service Commitment | service_offering | Offering | | Service Level Target | service_commitment | Commitment | | Service Level Target | service_level_definition | Definition | | Service Subscription | service_offering + consumer | | Task SLA | task + SLA definition (aus Commitment abgeleitet) | ## 5. Diagramm Mermaid flowchart with subgraphs. Let me draft carefully (Mermaid syntax): ```mermaid flowchart TB subgraph DESIGN["CSDM – Design Value Stream"] PORT[("Service Portfolio
service_portfolio")] SVC[("Service
service")] OFF[("Service Offering
service_offering")] CAT[("Service Catalog
service_catalog")] BAPP[("Business Application
apm_application")] AS[("Application Service
cmdb_ci_service_discovered")] TS[("Technical Service
cmdb_ci_service_technical")] end subgraph SELL["CSDM – Sell/Consume"] SUB[("Service Subscription
service_subscription")] CON["Consumer
(Account / Department)"] CMT[("Service Commitment
sla_service_commitment
SLA / OLA / UC")] TGT[("Service Level Target
sla_service_level_target")] DEF[("Service Level Definition
sla_service_definition")] end subgraph OPERATE["CSDM – Operate (CMDB)"] DCG[("Dynamic CI Group
cmdb_ci_dyn_group")] SRV["Server / VM / DB / Netzwerk / Datacenter
cmdb_ci_*"] end subgraph ITSM["ITSM-Prozesse (Task-Tabellen)"] INC["Incident / Problem / Change
incident, problem, change_request"] TSLA["Task SLA
task_sla"] end PORT --> SVC SVC --> OFF CAT --> OFF OFF -- "Is deployed as /
Deployed version of" --> AS AS -- "Supports / Supported by" --> BAPP TS -- "Supports / Supported by" --> AS AS -- "Runs on / Contains /
Depends on" --> SRV DCG -.-> AS CON -- "abonniert" --> SUB SUB --> OFF OFF --> CMT CMT --> TGT TGT --> DEF INC -- "service_offering" --> OFF INC -- "cmdb_ci" --> AS CMT -- "generiert" --> TSLA TSLA --> INC ``` Mermaid edge labels with slashes/parens may break; need quoting: `--"Is deployed as"-->`? Mermaid label syntax: `A -- "label" --> B` works. Multi-line with
works in labels. Keep labels short to avoid breakage: use `|Label|` syntax: `OFF -->|"Is deployed as"| AS`. Quotes inside pipe labels are okay. Let me use that syntax. Also `A["text"]` node definitions with
fine. Let me restructure the mermaid to be safe: ```mermaid flowchart LR subgraph Design PORT[Service Portfolio] SVC[Service] OFF[Service Offering] BAPP[Business Application] AS[Application Service] TS[Technical Service] end subgraph SellConsume CON[Consumer] SUB[Service Subscription] CMT[Service Commitment
SLA / OLA / UC] TGT[Service Level Target] DEF[Service Level Definition] end subgraph Operate SRV[CIs: Server, DB, Netzwerk, DC] DCG[Dynamic CI Group] end subgraph ITSM INC[Incident / Problem / Change] TSLA[Task SLA] end PORT --> SVC --> OFF OFF -->|"Is deployed as"| AS AS -->|"Supports"| BAPP TS -->|"Supports"| AS AS -->|"Runs on / Contains / Depends on"| SRV DCG -.->|"befüllt"| AS CON -->|"abonniert"| SUB SUB -->|"bezieht"| OFF OFF -->|"Commitment"| CMT CMT -->|"Ziele"| TGT TGT -->|"Metrik"| DEF INC -.->|"service_offering"| OFF INC -.->|"cmdb_ci"| AS CMT -.->|"generiert"| TSLA TSLA -.-> INC ``` `
` inside node labels: Mermaid accepts `
` in labels. Fine. Maybe a second small mermaid for Incident→Commitment→SLA flow? Could be a small numbered list instead. I'll do a compact flow list in text. Keep one diagram only to control length. ## 6. Wirkungsweise im ITSM-Betrieb (Beispiel-Fluss) 1. User meldet Incident via Katalog (RITM? no—incident via portal or agent). Agent wählt Service Offering "SAP ERP Betriebservice", System schlägt CI vor. 2. Priorität P1 → Matching Commitment SLA SAP ERP (24×7) → Targets: Reaktion 15 min, Lösung 2 h → Task SLAs an Incident. 3. Eskalation/Breach-Benachrichtigung; Berichte via Performance Analytics. 4. OLA/UC Rückgriff: Technisches Team sieht OLA Rechenzentrum; Hersteller-Ticket via UC. ## 7. Umsetzungshinweise / Best Practices - Minimal Viable CSDM: zuerst Service Offerings + Business Applications + App Services verbinden; CSDM Health/Compliance Dashboards (CSDM Data Certification). - Fallback-Richtlinien: Incidents ohne Offering → Fallback-Offering definieren. - Dynamic CI Groups fürApp-Services ohne Discovery. - Data certification für kritische Beziehungen. - Rollen: Service Owner vs Technical Service Owner vs Offering Owner (CSDM defines roles: Service Owner, Service Offering Owner, Technical Service Owner? — I recall CSDM v4 roles: Service Owner (service), Offering Owner, Application Service Owner? and "Managed by"/"Owned by" fields). Mention fields: service_offering has "owned by"/"managed by"? Business app has "application owner"? Keep generic. Also mention: "Commitments vs. klassische SLA-Definitionen (`sla`): CSDM-Ansatz nutzt Service Commitments; klassische Task-SLA-Definitionen weiterhin für einfache Fälle; beide laufen in `task_sla`." Length check: This will be a long answer. The user asked for a comprehensive deliverable ("Datenmodell mit Beispieldaten und einer Übersicht aller relevanten Beziehungen") — so long is appropriate. But I should keep it tight: use tables, avoid redundant prose. Aim for maybe 1200-1800 words equivalent with tables. Let me be disciplined: Sections: 1. Überblick CSDM-5-Struktur (kurz, bullet) 2. Kernentitäten & Tabellen (Tabelle) 3. Beispieldatenszenario (mehrere kompakte Tabellen) 4. Beziehungsübersicht (Tabelle: CMDB-Relationen + Referenzrelationen) 5. Modell-Diagramm (Mermaid) 6. Beispiel-End-to-End-Fluss Incident→SLA (kurz, nummeriert) 7. Praxis-/Umsetzungshinweise (kurz bullets) 8. Hinweis zu Tabellennamen/CSDM-5-Delta (kurz) Now, sample data consistency: IDs, names in German. Let me finalize numbers. Company: "ACME Industries AG" — I'll just call it "ACME AG". Design data: Portfolio: - PF001 "Unternehmens-IT-Portfolio" Services (service): - SVC001 "Arbeitsplatz & Collaboration" - SVC002 "Business Applications" - SVC003 "Infrastruktur & Netzwerk" Service Catalogs: - SC001 "Mitarbeiter-Self-Service" - SC002 "Business-Unit-Katalog" Offerings (service_offering): - OFF1001 "E-Mail & Collaboration Standard" — service SVC001, catalog SC001, status Published, Subscription - OFF1002 "E-Mail & Collaboration Premium" — SVC001, SC001 - OFF2001 "SAP ERP Betriebservice" — SVC002, SC002 - OFF3001 "Netzwerkdienste Standortbetrieb" — SVC003, SC002 (used for network incidents) — optional; include for completeness so VPN incident has an offering. Actually keep offering count at 4; good. Business Applications (apm_application): - BA001 "SAP ECC – Finanz & Logistik" (criticality: Mission-critical) - BA002 "Microsoft 365" (Business-critical) - BA003 "Intranet Portal" (Moderate) Application Services (cmdb_ci_service_discovered): - APPS001 "AS SAP ECC Produktion" (env: Production) → supports BA001 - APPS002 "AS SAP ECC Test" (env: Test) → supports BA001 - APPS003 "AS Exchange Online" (Production) → supports BA002 - APPS004 "AS SharePoint Online" (Production) → supports BA002 - APPS005 "AS Active Directory" (Production) → supports BA002? Also supports SAP? Add dependency: APPS001 Depends on APPS005. Technical Services (cmdb_ci_service_technical): - TECH001 "Microsoft 365 Tenant Management" → supports APPS003, APPS004, APPS005 - TECH002 "SAP Hosting Rechenzentrum Frankfurt" → supports APPS001, APPS002 - TECH003 "Standortnetzwerk & VPN" → supports APPS001? hmm network supports app services? network tech service supports... APPS001, APPS003. Fine. Deployed as: - OFF1001 → APPS003 (+ APPS004? Standard E-Mail offering includes Exchange+Teams? Keep: OFF1001 → APPS003; note one offering can map to several app services) - OFF2001 → APPS001 (Produktion). Test offering? OFF2001 covers prod; test app service also "deployed as" OFF2001? In CSDM, offering→app service mapping can include test? Typically offering maps to production app services; test environments under same offering? Many map offering to app service per environment? I'll map OFF2001 → APPS001 only, and note environments via `environment` field; test app service supports BA001 as well. OK. - OFF1002 → APPS003 (premium features) — hmm, premium uses same app service; mapping 1 offering→same app service is allowed (n:m actually). Note that. - OFF3001 → no app service (network offering maps to... could deploy as technical? In CSDM 4, offerings deploy as application services only? Or can they deploy as technical services? CSDM 4: Service Offering — Is deployed as — Application Service. CSDM 5 technical service offerings → technical services. So OFF3001 could map to... hmm. Maybe drop OFF3001 to avoid confusion, OR keep and note that a pure network offering might be modeled as Technical Service Offering in CSDM 5. That's a nice teaching point! Keep OFF3001 and note: "könnte in CSDM 5 als Technical Service Offering modelliert werden". Good. Sell/Consume data: Consumers (departments): - DEP010 "Finanzbuchhaltung" (120 MA) - DEP020 "Personal" (85 MA) - DEP030 "Vertrieb" (210 MA) - DEP040 "IT-Betrieb" (40) Subscriptions (service_subscription): - SUB0001 DEP030 → OFF1002, 210 Nutzer, ab 01.01.2025 - SUB0002 DEP020 → OFF1001, 85 Nutzer - SUB0003 DEP010 → OFF2001, 120 Nutzer - SUB0004 DEP010 → OFF1001, 120? (Finanz also uses mail) — add for realism: SUB0004 DEP010 → OFF1001 120. OK. Commitments (sla_service_commitment): - CMT0001 "SLA E-Mail & Collaboration" — Typ SLA — OFF1001 & OFF1002? one commitment per offering typically; make two: CMT0001 (OFF1001), CMT0002 (OFF1002)? To reduce rows, use one commitment CMT0001 for OFF1001 and CMT0002 for OFF2001 (SAP), CMT0003 OLA, CMT0004 UC. Note premium similar. - CMT0001: SLA, OFF1001, 24×7, TZ Europe/Berlin - CMT0002: SLA, OFF2001, 24×7 - CMT0003: OLA, Technical Service TECH002 (OLA attached to technical service? In CSDM, commitments attach to service offerings; OLA commitments attach to... hmm. Service Commitment table has "service offering" field; for OLA/UC you reference offerings too (internal offerings). In CSDM 3, OLA/UC commitments also reference service offerings (which may be internal/technical offerings). In CSDM 4 with technical services: commitments can reference technical services? I recall `sla_service_commitment` has field "service" (service_offering) and maybe "technical service"? Hmm. The commitment's field is "service_offering"? I believe the Service Commitment references a Service Offering (field name "service"). For OLA/UC, you'd create commitments on internal offerings. With CSDM 4/5 technical service offerings, OLAs attach to technical service offerings. To stay safe: model OLAs on the technical services via offerings note: "OLA am Technical Service/Technical Service Offering (CSDM 5) oder internen Offering". I'll present OLA CMT0003 attached to TECH002 via "Technical Service Offering 'SAP Hosting Frankfurt' (CSDM 5: Technical Service Offering)" — hmm, this adds an entity type I'm not 100% sure about table name for. Alternative: attach OLA to OFF2001 as "underpinning internal commitment" — the classic CSDM v3 way: commitment types SLA (customer-facing), OLA (internal), UC (external supplier), all referencing offerings. That's clean and well-documented for v3. I'll do that: OLA CMT0003 → OFF2001 (interne Zusage des Rechenzentrums an den SAP-Service), UC CMT0004 → OFF1001 (Microsoft-Support-Vertrag, unterpinning). And add note: "In CSDM 5 können OLAs/UCs auch an Technical (Service) Offerings hängen." This is defensible. Targets (sla_service_level_target): - T0001 CMT0001 — Verfügbarkeit ≥ 99,9 %/Monat (Definition: Availability) - T0002 CMT0001 — Reaktionszeit Incident ≤ 15 min (P1) - T0003 CMT0001 — Lösungszeit Incident ≤ 4 h (P1) - T0004 CMT0001 — Reaktionszeit ≤ 30 min (P2); T0005 Lösung ≤ 8 h (P2) - T0006 CMT0002 — Verfügbarkeit ≥ 99,5 %/Monat - T0007 CMT0002 — Lösungszeit ≤ 2 h (P1); T0008 ≤ 8 h (P2) - T0009 CMT0003 OLA — Verfügbarkeit Hosting ≥ 99,95 %/Monat - T0010 CMT0003 OLA — Reaktionszeit ≤ 10 min (P1) - T0011 CMT0004 UC — Hersteller-Reaktionszeit ≤ 60 min (Sev A) Definitions (sla_service_definition): - DEF01 "Verfügbarkeit" (unit %) - DEF02 "Reaktionszeit" (unit min) - DEF03 "Lösungszeit" (unit h? min) Operate data: CIs: - DC001 "Rechenzentrum Frankfurt" (cmdb_ci_datacenter) - SRV001 "sapapp01" (cmdb_ci_server, Linux, hosted in DC001) — Runs AS SAP ECC PRD - SRV002 "sapdb01" (cmdb_ci_server, Linux) — Runs DB - DB001 "SAP HANA PRD" (cmdb_ci_database) — contained by AS SAP ECC PRD, runs on SRV002 - NET001 "FW-FRA-01" (cmdb_ci_netgear) — contained by AS SAP ECC PRD - (SaaS note: AS Exchange Online hat keine gemanagten CIs; Betriebskontext via Technical Service) DCG: DCG001 "SAP ECC PRD Servers" (query: class=Server AND name starts sap* AND env=Production) → befüllt APPS001. Good. ITSM data: Incidents: - INC0010003 "SAP Login/Transaktion FB01 Timeout" — offering OFF2001, CI APPS001 (SAP HANA PRD as affected CI? put cmdb_ci = DB001? Usually cmdb_ci = app service or specific CI; I'll use APPS001 primary, mention DB001 in work notes) — P1 (Critical) — assignment group "SAP-Betrieb" — SLA: aus CMT0002 → Lösungszeit P1 2 h. - INC0010004 "Kein Mailversand möglich" — OFF1001, CI APPS003, P2 — group "Collaboration-Betrieb" — SLA CMT0001: Reaktion 30 min (erfüllt), Lösung 8 h. - INC0010005 "VPN-Standort Hamburg instabil" — OFF3001, CI? network? maybe skip third incident. Keep 2 + problem + change to stay compact. Hmm, three is nice for variety (one showing OLA/UC interplay). Let me include INC0010005 VPN with offering OFF3001, CI NET? there's no app service for network... cmdb_ci could be "FW-FRA-01"? VPN firewall — fine, CI = NET002 "VPN-Gateway HAM-01"? add CI. This also demonstrates commitment: CMT? OFF3001 has commitment? We didn't define. Could note "kein Commitment definiert → Fallback". That's a teaching moment: Fallback-Offering. OK include INC0010005 with "Fallback-SLA (Standard-SLA-Definition) da kein Offering-Commitment". Nice. Problem: PRB0040002 "HANA-Performance-Degradation nach HANA-Upgrade" — CI DB001; zugeordnete Incidents INC0010003. Change: CHG0030010 "HANA-Parameteranpassung (Standard-Change)" — CI DB001; Offering OFF2001; geplant. Task SLA samples: - task_sla for INC0010003: "SAP ERP – Lösungszeit P1" (hergeleitet aus CMT0002/T0007), Fällig: 14.05.2025 11:12, Status "In Verletzungngefahr"? Keep simple: Status: "Running / At Risk". Timestamps: Incident INC0010003 opened 14.05.2025 09:12 → due 11:12. INC0010004 opened 14.05. 08:40, response met 09:05 (25 min ≤ 30), resolution due 16:40. End-to-end flow section (kurz): describe how incident triggers commitment-based SLAs. Now the relationship overview table — "alle relevanten Beziehungen". Let me write comprehensive but structured: A. CMDB-Beziehungen (cmdb_rel_ci), Empfehlungen laut CSDM: | # | Beziehung (Parent → Child) | OOB-Beziehungstyp | Beispiel aus Beispieldaten | Zweck | |1| Service Offering → Application Service | Is deployed as :: Deployed version of | OFF2001 → APPS001 | Verknüpft Angebot mit operationaler Realisierung | |2| Application Service → Business Application | Supports :: Supported by | APPS001 → BA001 | Betriebsverantwortung für Fachanwendung | |3| Technical Service → Application Service | Supports :: Supported by | TECH002 → APPS001 | Technischer Betrieb | |4| Application Service → Server/Host | Runs on :: Runs | APPS001 → SRV001 | Laufzeitumgebung | |5| Application Service → Database | Contains :: Contained by | APPS001 → DB001 | Datenbestand des Dienstes | |6| Application Service → Netzwerkgerät | Contains :: Contained by | APPS001 → NET001 | Netzwerkkomponenten | |7| Application Service → Application Service | Depends on :: Used by | APPS001 → APPS005 (AD) | Dienstabhängigkeiten | |8| Database → Server | Runs on :: Runs | DB001 → SRV002 | DB-Laufzeit | |9| Server → Datacenter | Hosted in :: Hosts | SRV001 → DC001 | Standort (alternativ: Feld location) | |10| Application Service ← Dynamic CI Group | (Befüllung via Abfrage) | DCG001 → APPS001 | Automatische CI-Sammlung | Hmm #10 isn't a rel type; mark as mechanism. B. Referenz-/Feldbeziehungen (keine CMDB-Relations): | # | Objekt (Tabelle) | Feld | Ziel | Zweck | |1| Service (service) | portfolio | service_portfolio | Gruppierung | |2| Service Offering (service_offering) | service | service | Zuordnung zum Service | |3| Service Offering | catalog / Parent-Field? | service_catalog | Kanal | |4| Service Offering | parent | service_offering | Angebots-Hierarchie (optional) | |5| Service Subscription | service_offering, consumer | service_offering + customer_account/cmn_department/core_company | Wer konsumiert was (Lizenz/Abrechnung) | |6| Service Commitment | service (Offering) | service_offering | Vertragliche Zusage | |7| Service Commitment | schedule | cmdb_schedule | Gültigkeitszeiten | |8| Service Level Target | service_commitment | sla_service_commitment | Ziele je Vertrag | |9| Service Level Target | service_level_definition | sla_service_definition | Metrik | |10| Incident/Problem/Change | service_offering, service, cmdb_ci | ... | Tickets an Services binden | |11| Task SLA | task, sla | incident + SLA-Def (aus Commitment generiert) | SLA-Messung | |12| Business Application | application_manager / owned_by? | sys_user | Verantwortlichkeiten | Also roles: "Owned by / Managed by" on service_offering, technical service owner. Mermaid diagram as planned. Praxis-Hinweise bullets: - Fallback-Offerings definieren (Incidents ohne Angebot) - Reihenfolge der Implementierung: Business Apps → App Services → Offerings → Commitments - CSDM Health / Data Certification / CMDB Health Dashboards verwenden - Discovery + DCG kombinieren; SaaS-Dienste ohne CIs via Technical Service abbilden - Klassische SLA-Definitionen (`sla`) vs Commitments: Commitments sind der CSDM-Weg; beide erzeugen task_sla-Einträge - Reporting: Service Commitment Compliance-Dashboards CSDM-5-Hinweis: kurzer Absatz. One more consideration: the user wrote "Inc" (Incidents). Include problem/change/request briefly — yes covered. Table names verification footnote: "Tabellennamen entsprechend ServiceNow-Dokumentation (CSDM 4/5); einzelne Namen können je Release abweichen (z. B. cmdb_ci_service vor CSDM 4)." Now — German language throughout. Terms: "Wertstrom" for value stream; "Verbraucher/Konsument" for consumer. Also maybe include a short "Ebenen" note: Business Services vs Technical Services (CSDM distinguishes "Business Service Domain" and "Technical Service Domain"). Let me now also double-check `service_offering` vs CSDM 4: In CSDM 4, service_offering remains; the `service` table is new; offerings must reference a service record (field "service"). Yes I recall that requirement: In CSDM v4, every offering must have a parent "Service". Good. Also `service_offering` key fields: name, service, status ("Draft", "Published", "Retired"), "service catalog"? field name maybe "catalog"? Hmm. There's field "service_catalog"? hmm. I'll write "Katalog-Zuordnung" without exact field name to be safe. Also "subscription" flag? There is a field indicating offering is subscription-based? I recall "subscription_based"? Not sure. Skip exact. Business app table `apm_application` — key fields: name, description, "criticality" field is "business_criticality"? On apm_application there's "criticality"? The class cmdb_ci_business_app had "business_criticality". apm_application extends cmdb_ci_appl? Hmm — apm_application extends... I believe apm_application extends cmdb_ci (or task?) — it has fields like "business_criticality", "application_owner"? I'll list generic fields: Name, Business-Kritikalität, Verantwortlicher (Application Owner), Lebenszyklusstatus. Fine. Incident fields: number, short_description, priority (impact/urgency), service_offering, cmdb_ci, assignment_group, state. Good. Now, do I present sample data as tables with multiple rows — yes. Also worth including exact relationship type names in English (they're OOB English): "Supports::Supported by", "Runs on::Runs", "Contains::Contained by", "Depends on::Used by", "Is deployed as::Deployed version of", "Hosted in::Hosts". Provide German gloss. One more check — "Depends on::Used by": A Depends on B ⟺ B is Used by A. So AS SAP ECC PRD Depends on AS AD. In table: APPS001 "Depends on" APPS005. Good. "Supports::Supported by": A Supports B ⟺ B Supported by A. AS→BA: "AS SAP ECC Produktion Supports BA001" — the doc phrasing is Application Service supports Business Application. Good. "Is deployed as::Deployed version of": I'm going to write it as: Service Offering — "Is deployed as" → Application Service? Hmm, final decision time. Let me think really hard about the ServiceNow doc one more time. I recall the CSDM v3 whitepaper section "Service Offerings" instructing: "...relate your service offerings to the application services that support them"? That phrasing suggests App Service supports Offering — but the OOB suggested relationship type listed for service_offering ↔ cmdb_ci_service... I have a strong-ish memory of the pair being listed as: "cmdb_ci_service [Application Service] — Is deployed as::Deployed version of — service_offering [Service Offering]"? or reversed... Let me think about the CSDM 4 doc "Create service offerings": steps: 1) create service, 2) create offering, 3) ... "associate application services" via related list "Application Services"? If the related list on the offering shows "Application Services", then the relationship from offering side reads "Is deployed as" → meaning offering "Is deployed as" the application services? Hmm, hmm. Wait — hmm, I actually recall the related list on service_offering being called "Deployed as"? or "Application services"? I found a clearer memory!! The ServiceNow doc "Service Offering [service_offering]" page lists "Related lists: Application Services (Is deployed as::Deployed version of)"? Hmm, I can't verify. Alternatively, community knowledge: "The relationship between Service Offering and Application Service is 'Is deployed as::Deployed version of' where the Application Service is deployed as the Service Offering"?? That would mean: Application Service —Is deployed as→ Service Offering, and Service Offering is "Deployed version of" Application Service. Semantics: "The application service is deployed as a service offering"?? That reads oddly too. Hmm, think of another OOB usage of "Is deployed as::Deployed version of": I recall it's used between "Application Service" and "Software Instance"? or "Software Model → Application Service"? Hmm... In APM: "Business Application — Runs on — Application Service"? no. OK let me think about which direction makes ServiceNow docs consistent: In the CSDM 4 "Design value stream" reference diagram, the arrow between Service Offering and Application Service is labeled "Is deployed as" with arrow pointing FROM Service Offering TO Application Service. I have a visual memory of the CSDM v4 diagram: "Service Offering" on left top, "Application Service" right, arrow labeled... I genuinely can't retrieve it reliably. Decision: I'll write the row as: "Service Offering ↔ Application Service (Is deployed as / Deployed version of)" and in the example column: "OFF2001 'SAP ERP Betriebservice' ↔ APPS001 'AS SAP ECC Produktion'" with note "Das Application Service ist die operative Realisierung des Offerings". Direction-neutral presentation avoids propagating a possible error while still giving the correct type name. In the Mermaid diagram I need a direction though: I'll draw OFF --> AS labeled "Is deployed as". Given my semantic analysis ("the offering is deployed as the app service"), OFF → AS is my best guess and it's also the direction that matches "Is deployed as" reading parent→child if ServiceNow convention lists offering as parent. I'll go with OFF → AS in the diagram. And in the table I'll write "Service Offering – Is deployed as – Application Service" consistently. If I'm wrong on direction, the type name is still right and semantics clear. Acceptable. Similarly "Technical Service Supports Application Service": TS → AS with "Supports". Confident enough. Let me also reconsider: is it maybe "Application Service Is deployed as Service Offering"? If so my diagram would be reversed. Hmm. One more memory probe: ServiceNow docs "Recommended relationships: Service Offering": table row: "Service Offering | Is deployed as::Deployed version of | Application Service". I'm going to commit to this. I believe I've seen exactly this row. Yes — commit. Also for Business Application ↔ Application Service: doc row: "Application Service | Supports::Supported by | Business Application". Commit. Technical Service: "Technical Service | Supports::Supported by | Application Service". Commit. (CSDM 4 added technical services supporting app services.) Additional OOB suggested relations worth including: "Application Service | Depends on::Used by | Application Service" — yes. "Application Service | Runs on::Runs | Server" — hmm wait: is it "Runs on::Runs" or "Runs::Runs on"? The OOB type: "Runs on::Runs" — "Application Server Runs on Windows Server"? Hmm, actually I recall "Runs on::Runs" where e.g. "cmdb_ci_appl Runs on cmdb_ci_server"? Hmm, hmm. In Discovery, "Windows Service runs on Windows Server"? The rel type "Runs on::Runs" exists OOB: e.g., "Tomcat runs on Linux Server". Yes: parent=appl/service, child=server, type "Runs on". Reverse "Runs". Good. "Contains::Contained by": App Service contains DB — parent=app service, child=DB. Good. Also "App Service contains netgear" — I believe CSDM recommends "Contains" for network gear too. Hmm, actually for network gear I recall "Application Service — Connected by::Connects to — Netgear"? Discovery creates "IP Switch Connected by ..." Hmm: Discovery relates netgear to servers via "Connected by::Connects to"? For app services, CSDM guidance (v3 whitepaper, table "Recommended relationships for Application Services"): - Application Service — Runs on::Runs — Computer/Server - Application Service — Contains::Contained by — Database - Application Service — Contains::Contained by — Network gear? or "Runs on::Runs — Network gear"? I recall for network devices: "Application Service — Contains::Contained by — Network Gear". I'll go with Contains; add "(ggf. zusätzlich Connects to::Connected by zwischen Netzwerk-CIs)". Datacenter: "Hosted in::Hosts". I'll include with a soft note. Also mention "Business Application — Depends on::Used by — Business Application"? optional; skip to reduce noise. Maybe include one line "Business Application – Depends on – Business Application (optional, fachliche Abhängigkeiten)". Also Service Catalog → Service Offering: I'll express as reference; hmm in CSDM 4, is catalog↔offering a reference field on offering ("catalog")? I believe service_offering has "service_catalog"? hmm hmm. I'll phrase generically. Now write the final answer in German. Structure with headings (##), tables, mermaid code block, bullet lists. Keep prose tight. Start with a 1-2 sentence intro (no heavy preamble). Also add a short legend for table-name caveat. And maybe end with an offer to adapt (e.g., "Wenn du magst, liefere ich das als Excel-/Import-Template oder JSON"). A brief closing offer is fine per formatting guidance (optional). Keep it one line. Let me make sure the Mermaid syntax is valid: ```mermaid flowchart TB subgraph DESIGN["Design Value Stream (Design)"] PORT["Service Portfolio
service_portfolio"] SVC["Service
service"] OFF["Service Offering
service_offering"] BAPP["Business Application
apm_application"] AS["Application Service
cmdb_ci_service_discovered"] TS["Technical Service
cmdb_ci_service_technical"] end subgraph SELL["Sell/Consume Value Stream"] CON["Consumer
Account / Department"] SUB["Service Subscription
service_subscription"] CMT["Service Commitment
sla_service_commitment
(SLA / OLA / UC)"] TGT["Service Level Target
sla_service_level_target"] DEF["Service Level Definition
sla_service_definition"] end subgraph OP["Operate Value Stream (CMDB)"] DCG["Dynamic CI Group
cmdb_ci_dyn_group"] CI["Infrastruktur-CIs
cmdb_ci_server / _database /
_netgear / _datacenter ..."] end subgraph ITSM["ITSM (Task-Tabellen)"] INC["Incident / Problem / Change
incident, problem, change_request"] TSLA["Task SLA
task_sla"] end PORT --> SVC --> OFF OFF -->|"Is deployed as"| AS AS -->|"Supports"| BAPP TS -->|"Supports"| AS AS -->|"Runs on / Contains /
Depends on"| CI DCG -.->|"befüllt (Abfrage)"| AS CON -->|"abonniert"| SUB SUB -->|"bezieht"| OFF OFF -->|"verpflichtet"| CMT CMT -->|"Ziele"| TGT TGT -->|"Metrik"| DEF INC -.->|"service_offering"| OFF INC -.->|"cmdb_ci"| AS CMT -.->|"generiert"| TSLA TSLA -.->|"gemessen an"| INC ``` Mermaid: chained edges `PORT --> SVC --> OFF` are allowed in flowchart. Node labels with parentheses inside quotes are fine. `
` works. Edge labels with `/` inside quotes fine. Dotted edges `-.->` with label: `DCG -.->|"befüllt"| AS` valid. One concern: node id "AS" — fine. "DEF" fine. Now sample data tables. Let me write them compactly. Also I should include IDs like SVC001, OFF2001 etc. to make it concrete (good for import templates). Write the final response now. Keep it organized and not overly long. I'll aim for a well-structured document. Given the deliverable nature, length ~ this plan is fine. Also note about "Inc" → Incidents handled. One more thing: CSDM 5 note. I'll write: "CSDM 5.0 (2024) führt die Grundstruktur von CSDM 4.0 fort: Design, Sell/Consume, Operate; Business- und Technical-Domäne. Neuerungen betreffen u. a. Technical Services (inkl. Technical Service Offerings) und Verfeinerungen im Design-Bereich. Die unten gezeigten Kernentitäten/-beziehungen sind in 4.0 und 5.0 gleich; prüfe releaseabhängige Details in der offiziellen CSDM-Dokumentation." Hmm — should I claim "Technical Service Offerings"? Let me hedge with "u. a." and frame as "(z. B. Technical Service Offerings für den internen Verkauf technischer Dienste)". I'm reasonably comfortable. Also add: commit types can also attach to technical offerings. Fine. Table-name caveat note at the end of entity table: "Technische Tabellennamen gemäß ServiceNow-Doku; vor CSDM 4 hieß die Application-Service-Klasse cmdb_ci_service." Now, write everything. Section order: 1. Überblick: CSDM 5 in 60 Sekunden (kurz bullets) 2. Kernentitäten & Tabellen (Tabelle, gruppiert nach Wertestrom) 3. Beispieldaten „ACME AG" (multiple compact tables: Design, Sell/Consume, Operate, ITSM) 4. Beziehungsübersicht (A: CMDB-Relations; B: Feld-Referenzen) 5. Diagramm (Mermaid) 6. End-to-End-Beispiel: Incident → Commitment → SLA (kurz nummeriert) 7. Praxis-Hinweise (bullets) Let me draft each table's content carefully and concisely. ### Kernentitäten-Tabelle | Wertestrom | Entität | Tabelle | Wichtigste Felder / Zweck | Design: - Service Portfolio | service_portfolio | Gruppierung von Services; Name, Status - Service | service | Das „Was" des eigenen Leistungsangebots; Name, Portfolio, Status, Owner - Service Offering | service_offering | Konsumierbares Angebot; Name, Service, Katalog, Status (Draft/Published/Retired), Owner - Service Catalog | service_catalog | Kanal/Gruppierung von Offerings für Konsumenten | (CSDM 4/5) - Business Application | apm_application | Fachanwendung (Portfoliomgmt); Kritikalität, Application Owner - Application Service | cmdb_ci_service_discovered | Operationaler Dienst (CI); Environment, Operational Status - Technical Service | cmdb_ci_service_technical | Technologie-/Infrastrukturdienst; Owner, kritikalität? Sell/Consume: - Consumer | customer_account / cmn_department / core_company | Wer konsumiert (intern/extern) - Service Subscription | service_subscription | Offering + Consumer + Gültigkeit (Abonnement) - Service Commitment | sla_service_commitment | Vertragszusage; Typ SLA/OLA/UC, Offering, Schedule, Zeitzone - Service Level Target | sla_service_level_target | Ziel je Metrik & Priorität; Referenzen: Commitment, Definition - Service Level Definition | sla_service_definition | Metrikkatalog (Verfügbarkeit, Reaktionszeit, Lösungszeit) Operate: - Infrastruktur-CIs | cmdb_ci_server, cmdb_ci_database, cmdb_ci_netgear, cmdb_ci_datacenter, cmdb_ci_vm_instance … | Betriebsobjekte - Dynamic CI Group | cmdb_ci_dyn_group | Abfragebasierte CI-Gruppen → automatische App-Services ITSM: - Incident/Problem/Change | incident / problem / change_request | Felder: service, service_offering, cmdb_ci, assignment_group, priority - Task SLA | task_sla | Laufende SLA-Messung am Task (aus Commitments generiert) ### Beispieldaten **Design:** Portfolio: PF001 „Unternehmens-IT-Portfolio". Services + Offerings table: | ID | Service Offering | Service | Katalog | Status | | OFF1001 | E-Mail & Collaboration – Standard | SVC001 Arbeitsplatz & Collaboration | Mitarbeiter-Self-Service | Published | | OFF1002 | E-Mail & Collaboration – Premium | SVC001 | Mitarbeiter-Self-Service | Published | | OFF2001 | SAP ERP – Betriebservice | SVC002 Business Applications | Business-Unit-Katalog | Published | | OFF3001 | Netzwerkdienste – Standortbetrieb | SVC003 Infrastruktur & Netzwerk | Business-Unit-Katalog | Published | Business Applications: | ID | Name | Kritikalität | Application Owner | | BA001 | SAP ECC (Finanz & Logistik) | Mission-critical | M. Weber | | BA002 | Microsoft 365 | Business-critical | L. Krause | | BA003 | Intranet-Portal | Moderat | T. Bauer | Application Services + Technical Services: | ID | Application Service | Env. | Supports (Business App) | Supported by (Tech. Service) | | APPS001 | AS SAP ECC Produktion | Prod | BA001 | TECH002 | | APPS002 | AS SAP ECC Test | Test | BA001 | TECH002 | | APPS003 | AS Exchange Online | Prod | BA002 | TECH001 | | APPS004 | AS SharePoint Online | Prod | BA002 | TECH001 | | APPS005 | AS Active Directory | Prod | BA002 | TECH001 | | ID | Technical Service | Supported by? | Unterstützt Application Services | | TECH001 | Microsoft 365 Tenant Management | – | APPS003, APPS004, APPS005 | | TECH002 | SAP Hosting Rechenzentrum Frankfurt | – | APPS001, APPS002 | | TECH003 | Standortnetzwerk & VPN | – | APPS001, APPS003 | **Sell/Consume:** Subscriptions: | ID | Consumer | Offering | Nutzer | ab | | SUB0001 | Abteilung Finanzbuchhaltung (DEP010) | OFF2001 | 120 | 01.01.2025 | | SUB0002 | Abteilung Personal (DEP020) | OFF1001 | 85 | 01.01.2025 | | SUB0003 | Abteilung Vertrieb (DEP030) | OFF1002 | 210 | 01.01.2025 | | SUB0004 | Abteilung Finanzbuchhaltung (DEP010) | OFF1001 | 120 | 01.01.2025 | Commitments: | ID | Bezeichnung | Typ | Bezug | Zeitplan | | CMT0001 | SLA E-Mail & Collaboration | SLA | OFF1001 | 24×7 | | CMT0002 | SLA SAP ERP Betriebservice | SLA | OFF2001 | 24×7 | | CMT0003 | OLA Rechenzentrum SAP Hosting | OLA | OFF2001 (unterstützend, intern) | 24×7 | | CMT0004 | UC Microsoft Unified Support | UC | OFF1001 (unterstützend, extern) | 24×5 | Targets: | ID | Commitment | Metrik | Zielwert | Priorität | | TGT001 | CMT0001 | Verfügbarkeit | ≥ 99,9 % / Monat | – | | TGT002 | CMT0001 | Reaktionszeit Incident | ≤ 15 min | P1 | | TGT003 | CMT0001 | Lösungszeit Incident | ≤ 4 h | P1 | | TGT004 | CMT0001 | Reaktionszeit Incident | ≤ 30 min | P2 | | TGT005 | CMT0001 | Lösungszeit Incident | ≤ 8 h | P2 | | TGT006 | CMT0002 | Verfügbarkeit | ≥ 99,5 % / Monat | – | | TGT007 | CMT0002 | Lösungszeit Incident | ≤ 2 h | P1 | | TGT008 | CMT0002 | Lösungszeit Incident | ≤ 8 h | P2 | | TGT009 | CMT0003 | Verfügbarkeit Hosting | ≥ 99,95 % / Monat | – | | TGT010 | CMT0004 | Hersteller-Reaktionszeit | ≤ 60 min | Sev A | Definitions: | ID | Definition | Einheit | | DEF001 | Verfügbarkeit | % | | DEF002 | Reaktionszeit | min | | DEF003 | Lösungszeit | h | **Operate:** | CI | Klasse | Details | Wichtige Beziehungen | | DC001 Rechenzentrum Frankfurt | cmdb_ci_datacenter | – | Hosts SRV001, SRV002 | | SRV001 sapapp01 | cmdb_ci_server | Linux, Prod | Runs APPS001; Hosted in DC001 | | SRV002 sapdb01 | cmdb_ci_server | Linux, Prod | Runs DB001; Hosted in DC001 | | DB001 SAP HANA PRD | cmdb_ci_database | HANA 2.0 | Contained by APPS001; Runs on SRV002 | | NET001 FW-FRA-01 | cmdb_ci_netgear | Firewall | Contained by APPS001 | | DCG001 SAP ECC PRD Server | cmdb_ci_dyn_group | Abfrage: Server, Name „sap*", Env=Prod | Befüllt APPS001 | Note: AS Exchange Online (SaaS) hat keine eigenen CIs; Kontext via TECH001. **ITSM:** | Nr | Typ | Kurzbeschreibung | Offering | CI | Priorität | Assignment Group | SLA (aus Commitment) | | INC0010003 | Incident | SAP FB01 Timeouts | OFF2001 | APPS001 | P1 | SAP-Betrieb | Lösung ≤ 2 h (TGT007), fällig 14.05. 11:12 | | INC0010004 | Incident | Kein Mailversand | OFF1001 | APPS003 | P2 | Collaboration-Betrieb | Reaktion ≤ 30 min (erfüllt), Lösung ≤ 8 h (TGT005) | | INC0010005 | Incident | VPN Hamburg instabil | OFF3001 | – | P3 | Netzwerk-Team | Fallback-SLA (kein Commitment am Offering) | | PRB0040002 | Problem | HANA-Performance-Degradation | OFF2001 | DB001 | – | SAP-Betrieb | verweist auf INC0010003 | | CHG0030010 | Change | HANA-Parameteranpassung | OFF2001 | DB001 | – | SAP-Basis | Standard-Change, geplant 21.05. | ### Beziehungsübersicht Table A (CMDB): | # | Parent | Beziehungstyp (OOB) | Child | Beispiel | Zweck | 1 Service Offering | Is deployed as | Application Service | OFF2001 → APPS001 | Angebot ↔ operative Realisierung 2 Application Service | Supports | Business Application | APPS001 → BA001 | Betriebsverantwortung 3 Technical Service | Supports | Application Service | TECH002 → APPS001 | Technischer Betrieb 4 Application Service | Runs on | Server/Host | APPS001 → SRV001 | Laufzeitumgebung 5 Application Service | Contains | Database | APPS001 → DB001 | Datenbestand 6 Application Service | Contains | Netzwerkgerät | APPS001 → NET001 | Netzanteil 7 Application Service | Depends on | Application Service | APPS001 → APPS005 | Dienstabhängigkeit 8 Database | Runs on | Server | DB001 → SRV002 | DB-Laufzeit 9 Server | Hosted in | Datacenter | SRV001 → DC001 | Standort (altern. Location-Feld) Each with the reverse type in parentheses: "Is deployed as / Deployed version of" etc. I'll show "Typ (hin ↔ zurück)". Table B (Feldreferenzen): | # | Objekt | Feld → Ziel | Zweck | 1 Service → portfolio → Portfolio 2 Service Offering → service → Service 3 Service Offering → Katalog → Service Catalog 4 Service Offering → parent → übergeordnetes Offering (optional, Bündel) 5 Service Subscription → service_offering + consumer (Account/Department/Company) 6 Service Commitment → service_offering (+ cmdb_schedule für Zeiten) 7 Service Level Target → service_commitment + service_level_definition 8 Incident/Problem/Change → service, service_offering, cmdb_ci 9 Task SLA → task + SLA-Definition (generiert aus Commitment/Target) 10 Commitment/Target → Owner-Felder? skip. ### End-to-end flow (short numbered): 1. Nutzer/Agent erfasst INC0010003, wählt Offering OFF2001 → System leitet Service, Verantwortlichkeiten ab. 2. P1 gesetzt → Plattform matcht Commitment CMT0002 (24×7) und generiert Task-SLAs aus TGT007/TGT008 (Lösung ≤ 2 h; P2-Fallback 8 h). 3. Incident bleibt 30 min ohne Fortschritt → Warnung „At Risk"; Breach-Benachrichtigung an Service Owner. 4. OLA CMT0003: Rechenzentrums-Team intern gemessen; bei Herstellersoftware greift UC CMT0004 (Microsoft-Ticket). 5. Reporting: Commitment-Compliance pro Offering/Subscription via Performance Analytics. ### Praxis-Hinweise (bullets): - Fallback-Offerings definieren (z. B. „Standard-Support") für Tickets ohne Offering → sauberes SLA-Reporting. - Reihenfolge der Implementierung: Business Apps → App Services → Offerings → Commitments - Discovery für technische CIs, DCG für App-Services ohne Discovery/Muster; SaaS ohne CIs über Technical Services abdecken. - CSDM-Health-/Compliance-Dashboards + Data Certification für kritische Beziehungen (Offering↔App Service, App Service↔Business App) nutzen. - Klassische SLA-Definitionen (`sla`) nur noch für Spezialfälle; Commitment-Ansatz ist CSDM-konform und erzeugt dieselben `task_sla`-Datensätze. - Verantwortlichkeiten modellieren: Service Owner (Service), Offering Owner, Technical Service Owner (Felder owned_by/managed_by). - CSDM-5-Delta: u. a. Technical Service Offerings für den internen „Verkauf" technischer Dienste; Tabellennamen ggf. releaseabhängig gegen die offizielle CSDM-Doku prüfen. Closing line: offer to export as import templates (CSV/XML) or adapt to their landscape. Now — check the claim "Commitment-Ansatz erzeugt dieselben task_sla Datensätze": In ServiceNow, Service Commitments generate "SLA definitions" per target? Actually the mechanism: "Service Commitments" + "Service Level Targets" can be attached to tasks and tracked — there's a feature where commitments appear as "SLAs" on tasks? I recall the "Commitment-based SLAs" feature: when you set service offering on a task, associated commitments create task SLA entries (sla_service_level_target related list "Task SLAs"?) Hmm. There is a documented feature: "Service commitment based SLAs" where service commitments' targets are enforced on tasks via the SLA engine, creating task_sla records with "service commitment" reference? I believe task_sla got a field "service level target"? Hmm. Not sure. I'll phrase cautiously: "aus den Commitment-Targets werden Task-SLAs (task_sla) generiert und wie klassische SLAs überwacht." That's the intended design; fine. Also priority mapping: Service Level Targets have "task type" and "priority"? I recall targets can be priority-specific. Keep generic wording "je Priorität". Also, service_offering field on incident: yes ("Service offering"). Also "Service" field referencing `service` table (CSDM v4+). Good. Regarding Dynamic CI Group table name: `cmdb_ci_dyn_group` — I'm fairly confident. Hmm, one more check: I recall "Dynamic CI Group [cmdb_ci_dyn_group]" — yes I'm going with it. Hmm, wait — is it maybe "u_dynamic_ci_group"? No, that's for custom. There's also "cmdb_ci_query_group"? no. I recall the DCG module "CMDB Dynamic Groups" with table... I'm going with cmdb_ci_dyn_group. Actually hold on, I want to reconsider — I have a nagging feeling the DCG table is `cmdb_ci_dyn_group`... yes, e.g., docs: "cmdb_ci_dyn_group — Dynamic CI Group". OK good. sla_service_definition — final check: I'm fairly sure CSDM tables: sla_service_commitment, sla_service_level_target, sla_service_definition. The pattern matches "SLA framework for CSDM" tables. Yes, commit. service_subscription — commit. consumer field references customer_account, cmn_department, core_company — I recall subscription consumer types: Account, Department, Company. Good. apm_application — commit (CSDM 4 moved business apps to APM table). I'll note "(vor CSDM 4: cmdb_ci_business_app)". cmdb_ci_service_discovered — commit with note "(vor CSDM 4: cmdb_ci_service)". service_catalog — I'll mention with slight hedge "(CSDM 4/5)" but not dwell. Actually, hmm, let me reconsider whether "Service Catalog" entity exists in CSDM 4... I recall CSDM v4 docs mention "Service catalogs" in Design value stream — yes, I'm fairly sure CSDM 4 introduced Service Catalog as a new entity (table service_catalog) to group offerings for different consumer audiences. Commit with light touch. Technical service table cmdb_ci_service_technical — commit. "Hosted in::Hosts" for datacenter — keep with soft note. Alright — also the user said "Inc" which I read as Incidents; I've covered incidents prominently. Response language: German. Use "du" or "Sie"? The user wrote informal-ish German without salutation; typical tech forum style. I'll use neutral/du? Safer: use "Sie"? Hmm, German tech communities often use "du". The prompt has no pronouns. I'll write mostly impersonal and use "du" sparingly at the end offer ("Wenn du möchtest...") — hmm, risk of mismatch. Alternatively phrase impersonally: "Auf Wunsch lässt sich das Modell als CSV-Import-Template aufbereiten." That avoids the choice mostly. I'll use one "du" in the closing offer — actually to be safe, impersonal phrasing throughout. Fine. Now write final answer. Keep tables compact (avoid too-wide tables). Use bold sparingly. Headers with ##. Let me count sections and trim prose. I'll write it now. # ITSM-Datenmodell auf Basis von ServiceNow CSDM 5 ## 1. Grundstruktur von CSDM 5 CSDM 5 baut auf CSDM 4.0 auf und strukturiert Servicedaten in drei Wertströme (Value Streams): - **Design**: Was bieten wir an? → Service Portfolio, Service, Service Offering, Business Application, Application Service, Technical Service - **Sell/Consume**: Wer konsumiert was und mit welcher Zusage? → Consumer, Service Subscription, Service Commitments (SLA/OLA/UC), Service Level Targets/Definitions - **Operate**: Womit wird es betrieben? → Konfigurationselemente (CIs) und ihre Beziehungen, Dynamic CI Groups Hinweis: CSDM 5 verfeinert das Modell von CSDM 4.0 (u. a. Technical Services mit Technical Service Offerings für den internen „Verkauf" technischer Dienste). Tabellennamen können je Release leicht abweichen. --- ## 2. Kernentitäten und Tabellen | Wertestrom | Entität | Tabelle | Zweck / Schlüsselfelder | |---|---|---|---| | Design | Service Portfolio | `service_portfolio` | Gruppierung von Services | | Design | Service | `service` | Das „Was" aus Produzentensicht (neu in CSDM 4+) | | Design | Service Offering | `service_offering` | Konsumierbares Angebot; Felder: service, status, owner | | Design | Service Catalog | `service_catalog` | Kanal-/Zielgruppen-Sicht auf Offerings | | Design | Business Application | `apm_application` | Fachanwendung; Kritikalität, Application Owner (vor CSDM 4: `cmdb_ci_business_app`) | | Design | Application Service | `cmdb_ci_service_discovered` | Operationaler Dienst (CI); Environment, Operational Status (vor CSDM 4: `cmdb_ci_service`) | | Design | Technical Service | `cmdb_ci_service_technical` | Technologie-/Infrastrukturdienst | | Sell/Consume | Consumer | `customer_account` / `cmn_department` / `core_company` | Interner/externer Konsument | | Sell/Consume | Service Subscription | `service_subscription` | Offering + Consumer + Gültigkeit | | Sell/Consume | Service Commitment | `sla_service_commitment` | Zusage vom Typ **SLA** (kundenorientiert), **OLA** (intern), **UC** (Hersteller); Schedule, Zeitzone | | Sell/Consume | Service Level Target | `sla_service_level_target` | Zielwert je Metrik und Priorität | | Sell/Consume | Service Level Definition | `sla_service_definition` | Metrikkatalog (Verfügbarkeit, Reaktionszeit, Lösungszeit) | | Operate | Infrastruktur-CIs | `cmdb_ci_server`, `cmdb_ci_database`, `cmdb_ci_netgear`, `cmdb_ci_datacenter`, `cmdb_ci_vm_instance` … | Betriebsobjekte | | Operate | Dynamic CI Group | `cmdb_ci_dyn_group` | Abfragebasierte CI-Gruppen → automatische Befüllung von Application Services | | ITSM | Incident / Problem / Change | `incident` / `problem` / `change_request` | Felder: `service`, `service_offering`, `cmdb_ci`, `priority`, `assignment_group` | | ITSM | Task SLA | `task_sla` | Laufende SLA-Messung am Ticket (aus Commitments generiert) | --- ## 3. Beispieldaten – Szenario „ACME AG" ### 3.1 Design Value Stream **Services & Offerings** | ID | Service Offering | Service | Katalog | Status | |---|---|---|---|---| | OFF1001 | E-Mail & Collaboration – Standard | SVC001 Arbeitsplatz & Collaboration | Mitarbeiter-Self-Service | Published | | OFF1002 | E-Mail & Collaboration – Premium | SVC001 | Mitarbeiter-Self-Service | Published | | OFF2001 | SAP ERP – Betriebservice | SVC002 Business Applications | Business-Unit-Katalog | Published | | OFF3001 | Netzwerkdienste – Standortbetrieb | SVC003 Infrastruktur & Netzwerk | Business-Unit-Katalog | Published | Alle Services hängen am Portfolio **PF001 „Unternehmens-IT-Portfolio"**. **Business Applications** | ID | Name | Kritikalität | Application Owner | |---|---|---|---| | BA001 | SAP ECC (Finanz & Logistik) | Mission-critical | M. Weber | | BA002 | Microsoft 365 | Business-critical | L. Krause | | BA003 | Intranet-Portal | Moderat | T. Bauer | **Application Services (CI-Klasse)** | ID | Application Service | Umgebung | Supported by (Technical Service) | |---|---|---|---| | APPS001 | AS SAP ECC Produktion | Production | TECH002 | | APPS002 | AS SAP ECC Test | Test | TECH002 | | APPS003 | AS Exchange Online (SaaS) | Production | TECH001 | | APPS004 | AS SharePoint Online (SaaS) | Production | TECH001 | | APPS005 | AS Active Directory | Production | TECH001 | **Technical Services** | ID | Technical Service | Unterstützt | |---|---|---| | TECH001 | Microsoft 365 Tenant Management | APPS003, APPS004, APPS005 | | TECH002 | SAP Hosting Rechenzentrum Frankfurt | APPS001, APPS002 | | TECH003 | Standortnetzwerk & VPN | APPS001, APPS003 | ### 3.2 Sell/Consume Value Stream **Subscriptions** | ID | Consumer | Offering | Nutzer | ab | |---|---|---|---|---| | SUB0001 | Abteilung Finanzbuchhaltung | OFF2001 | 120 | 01.01.2025 | | SUB0002 | Abteilung Personal | OFF1001 | 85 | 01.01.2025 | | SUB0003 | Abteilung Vertrieb | OFF1002 | 210 | 01.01.2025 | | SUB0004 | Abteilung Finanzbuchhaltung | OFF1001 | 120 | 01.01.2025 | **Service Commitments (SLA / OLA / UC)** | ID | Bezeichnung | Typ | Bezug | Zeitplan | |---|---|---|---|---| | CMT0001 | SLA E-Mail & Collaboration | SLA | OFF1001 | 24×7 | | CMT0002 | SLA SAP ERP Betriebservice | SLA | OFF2001 | 24×7 | | CMT0003 | OLA Rechenzentrum SAP Hosting | OLA | OFF2001 (unterstützend, intern) | 24×7 | | CMT0004 | UC Microsoft Unified Support | UC | OFF1001 (unterstützend, extern) | 24×5 | **Service Level Targets** (Definitionen: DEF001 Verfügbarkeit (%), DEF002 Reaktionszeit (min), DEF003 Lösungszeit (h)) | ID | Commitment | Metrik | Zielwert | Priorität | |---|---|---|---|---| | TGT001 | CMT0001 | Verfügbarkeit | ≥ 99,9 % / Monat | – | | TGT002 | CMT0001 | Reaktionszeit Incident | ≤ 15 min | P1 | | TGT003 | CMT0001 | Lösungszeit Incident | ≤ 4 h | P1 | | TGT004 | CMT0001 | Reaktionszeit Incident | ≤ 30 min | P2 | | TGT005 | CMT0001 | Lösungszeit Incident | ≤ 8 h | P2 | | TGT006 | CMT0002 | Verfügbarkeit | ≥ 99,5 % / Monat | – | | TGT007 | CMT0002 | Lösungszeit Incident | ≤ 2 h | P1 | | TGT008 | CMT0002 | Lösungszeit Incident | ≤ 8 h | P2 | | TGT009 | CMT0003 | Verfügbarkeit Hosting | ≥ 99,95 % / Monat | – | | TGT010 | CMT0004 | Hersteller-Reaktionszeit | ≤ 60 min | Sev A | ### 3.3 Operate Value Stream (CI-Landschaft) | CI | Klasse | Details | Wichtige Beziehungen | |---|---|---|---| | DC001 Rechenzentrum Frankfurt | `cmdb_ci_datacenter` | – | Hosts SRV001, SRV002 | | SRV001 sapapp01 | `cmdb_ci_server` | Linux, Prod | APPS001 Runs on SRV001; Hosted in DC001 | | SRV002 sapdb01 | `cmdb_ci_server` | Linux, Prod | DB001 Runs on SRV002 | | DB001 SAP HANA PRD | `cmdb_ci_database` | HANA 2.0 | Contained by APPS001; Runs on SRV002 | | NET001 FW-FRA-01 | `cmdb_ci_netgear` | Firewall | Contained by APPS001 | | DCG001 „SAP ECC PRD Server" | `cmdb_ci_dyn_group` | Abfrage: Klasse Server, Name „sap*", Env = Prod | Befüllt APPS001 automatisch | > Hinweis: SaaS-Application Services wie AS Exchange Online haben i. d. R. keine eigenen gemanagten CIs – der Betriebskontext wird über den Technical Service (TECH001) abgebildet. ### 3.4 ITSM-Beispieldaten | Nr | Typ | Kurzbeschreibung | Offering | CI | Priorität | Gruppe | SLA (aus Commitment) | |---|---|---|---|---|---|---|---| | INC0010003 | Incident | SAP FB01 Timeouts | OFF2001 | APPS001 | P1 | SAP-Betrieb | Lösung ≤ 2 h (TGT007), fällig 14.05. 11:12 | | INC0010004 | Incident | Kein Mailversand | OFF1001 | APPS003 | P2 | Collaboration-Betrieb | Reaktion ≤ 30 min (erfüllt), Lösung ≤ 8 h (TGT005) | | INC0010005 | Incident | VPN Hamburg instabil | OFF3001 | – | P3 | Netzwerk-Team | Fallback-SLA (kein Commitment am Offering) | | PRB0040002 | Problem | HANA-Performance-Degradation | OFF2001 | DB001 | – | SAP-Betrieb | verknüpft mit INC0010003 | | CHG0030010 | Change | HANA-Parameteranpassung | OFF2001 | DB001 | – | SAP-Basis | Standard-Change, geplant 21.05. | --- ## 4. Beziehungsübersicht ### A) CMDB-Beziehungen (`cmdb_rel_ci`) – OOB-Empfehlungen laut CSDM | # | Parent | Beziehungstyp (hin ↔ zurück) | Child | Beispiel | |---|---|---|---|---| | 1 | Service Offering | **Is deployed as** ↔ Deployed version of | Application Service | OFF2001 ↔ APPS001 | | 2 | Application Service | **Supports** ↔ Supported by | Business Application | APPS001 → BA001 | | 3 | Technical Service | **Supports** ↔ Supported by | Application Service | TECH002 → APPS001 | | 4 | Application Service | **Runs on** ↔ Runs | Server/Host | APPS001 → SRV001 | | 5 | Application Service | **Contains** ↔ Contained by | Database | APPS001 → DB001 | | 6 | Application Service | **Contains** ↔ Contained by | Netzwerkgerät | APPS001 → NET001 | | 7 | Application Service | **Depends on** ↔ Used by | Application Service | APPS001 → APPS005 (AD) | | 8 | Database | **Runs on** ↔ Runs | Server | DB001 → SRV002 | | 9 | Server | **Hosted in** ↔ Hosts | Datacenter | SRV001 → DC001 (alternativ über Location-Feld) | ### B) Referenz-/Feldbeziehungen (keine CMDB-Relations) | # | Objekt | Feld → Ziel | Zweck | |---|---|---|---| | 1 | Service | portfolio → `service_portfolio` | Portfoliosteuerung | | 2 | Service Offering | service → `service` | Zuordnung zum übergeordneten Service | | 3 | Service Offering | Katalog-Zuordnung → `service_catalog` | Kanal-/Zielgruppensicht | | 4 | Service Offering | parent → übergeordnetes Offering | Angebotsbündel/-hierarchie (optional) | | 5 | Service Subscription | service_offering + consumer (Account/Department/Company) | Wer konsumiert was | | 6 | Service Commitment | service_offering → `service_offering`; schedule → `cmdb_schedule` | Vertragszusage mit Gültigkeitszeiten | | 7 | Service Level Target | service_commitment + service_level_definition | Ziele je Vertrag und Metrik | | 8 | Incident / Problem / Change | service, service_offering, cmdb_ci | Ticket an Service und betroffenes CI binden | | 9 | Task SLA | task + generierte SLA-Definition (aus Commitment-Target) | Messung/Überwachung | --- ## 5. Modell-Diagramm ```mermaid flowchart TB subgraph DESIGN["Design Value Stream"] PORT["Service Portfolio
service_portfolio"] SVC["Service
service"] OFF["Service Offering
service_offering"] BAPP["Business Application
apm_application"] AS["Application Service
cmdb_ci_service_discovered"] TS["Technical Service
cmdb_ci_service_technical"] end subgraph SELL["Sell/Consume Value Stream"] CON["Consumer
Account / Department"] SUB["Service Subscription
service_subscription"] CMT["Service Commitment
sla_service_commitment
(SLA / OLA / UC)"] TGT["Service Level Target
sla_service_level_target"] DEF["Service Level Definition
sla_service_definition"] end subgraph OP["Operate Value Stream (CMDB)"] DCG["Dynamic CI Group
cmdb_ci_dyn_group"] CI["Infrastruktur-CIs
Server / DB / Netzwerk / Datacenter"] end subgraph ITSM["ITSM-Prozesse"] INC["Incident / Problem / Change"] TSLA["Task SLA
task_sla"] end PORT --> SVC --> OFF OFF -->|"Is deployed as"| AS AS -->|"Supports"| BAPP TS -->|"Supports"| AS AS -->|"Runs on / Contains /
Depends on"| CI DCG -.->|"befüllt per Abfrage"| AS CON -->|"abonniert"| SUB SUB -->|"bezieht"| OFF OFF -->|"Commitment"| CMT CMT -->|"Ziele"| TGT TGT -->|"Metrik"| DEF INC -.->|"service_offering"| OFF INC -.->|"cmdb_ci"| AS CMT -.->|"generiert"| TSLA TSLA -.->|"überwacht"| INC ``` --- ## 6. End-to-End-Beispiel: Incident → Commitment → SLA 1. Agent erfasst **INC0010003** und wählt Service Offering **OFF2001 (SAP ERP Betriebservice)** → System leitet Service, Owning-Team und Kritikalität ab. 2. Priorität **P1** wird gesetzt → die Plattform matcht Commitment **CMT0002** (SLA, 24×7) und generiert aus **TGT007** einen Task-SLA (Lösung ≤ 2 h). 3. Nach 30 min ohne Fortschritt → Status „At Risk", Eskalation an den Service Owner; bei Breach automatische Benachrichtigung. 4. Unterpinning greift: intern über **OLA CMT0003** (Rechenzentrum), beim Herstellersystem über **UC CMT0004**. 5. Reporting: Commitment-Compliance pro Offering/Subscription (z. B. Performance Analytics). --- ## 7. Praxis-Hinweise - **Fallback-Offering** definieren (z. B. „Standard-Support") für Tickets ohne Offering-Auswahl → sauberes SLA-Reporting (siehe INC0010005). - **Einführungsreihenfolge**: Business Applications → Application Services → Service Offerings → Commitments → Subscriptions. - **Discovery + Dynamic CI Groups** kombinieren; SaaS-Dienste ohne CIs über Technical Services abbilden. - **CSDM Health / Data Certification** nutzen, insbesondere für die kritischen Beziehungen Offering ↔ App Service und App Service ↔ Business Application. - **Klassische SLA-Definitionen (`sla`)** nur für Spezialfälle; der CSDM-konforme Weg sind Service Commitments (beide landen in `task_sla`). - **Verantwortlichkeiten** modellieren: Service Owner, Offering Owner, Technical Service Owner (Felder `owned_by`/`managed_by`). Auf Wunsch lässt sich das Modell als CSV-/XML-Import-Template (Load-Daten für Service Offering, Commitments, CIs und Relations) aufbereiten oder an eure konkrete Service-Landschaft angepasst werden.

Erstelle ein Datenmodell mit Beispieldaten und einer Übersic...