Overview of end-to-end DevOps integration-Cloud Monitor(CMS)-阿里云帮助中心

Case study materials

Download the materials for this use case: umodel-full-devops.zip.

Background and challenges

As AI becomes integral to software development, traditional DevOps processes are evolving toward an AI-native approach. From AI-assisted coding to intelligent O&M, the entire software lifecycle requires a unified system that integrates AI capabilities across every stage, from code development to production operations.

Core pain points

1. Data silos across multiple systems

Problem type	Description	Impact
Scattered development toolchains	Code repositories, CI/CD platforms, and issue tracking systems operate independently.	Fragmented data prevents a unified view.
Fragmented O&M monitoring	Application monitoring, infrastructure monitoring, and business monitoring lack a unified view.	Troubleshooting is inefficient.
Difficulty associating data	Code changes, deployment events, and runtime exceptions cannot be effectively associated.	Root cause analysis is difficult.

2. Inconsistent data formats

Problem type	Description	Impact
Inconsistent schemas	Different systems use different data formats and field definitions.	Data integration costs are high.
Semantic conflicts	The same concepts have different names and representations across systems.	Semantic understanding becomes inconsistent.

3. Difficulty retrieving runtime data

Problem type	Description	Impact
Lack of real-time data	Updates to critical runtime status information are delayed.	Abnormal events cannot be addressed quickly.
Missing relationships	The relationships between services, instances, and code cannot be quickly identified.	Problems are harder to identify.
Loss of context	No complete system status snapshot is available when a failure occurs.	Failures are difficult to reproduce and analyze.

4. Obstacles to AI understanding and analysis

Problem type	Description	Impact
Large amount of unstructured data	Logs and alert information are mostly in text format.	AI struggles to understand and process this data.
Implicit relationship information	Dependencies between system components are unclear.	Analysis accuracy is reduced.
Lack of a semantic layer	Data lacks standardized descriptions of business and technical semantics.	AI analysis lacks context.

Solutions

The UModel-based observability solution for end-to-end DevOps addresses these challenges with the following objectives:

Core objectives

Unify multiple systems: Consolidate personnel efficiency analysis, operational analysis, troubleshooting, and O&M control into a single platform to reduce tool-switching overhead.
Unify development and operations: Model data from the development (Dev) and operations (Ops) stages in a unified way to enable end-to-end analysis.
Improve overall efficiency: Integrate AI deeply into every stage to achieve truly intelligent DevOps. The expected overall efficiency improvement is over XX%.

Example of UModel solution architecture

Note: The following architecture and implementation are examples. Adjust them for your business scenarios as needed.

1. Unified representation with a graph model

UModel uses a graph model to represent the complete system architecture:

Development domain (organization)   O&M domain (ops)
┌─────────────────┐         ┌─────────────────┐
│  AI tool         │◄────────┤  Cluster          │
│  Developer       │         │  Host             │
│  Code repository │◄────────┤  Server role      │
│  Code release    │         │  Service template │
└─────────────────┘         │  Service version  │
                            └─────────────────┘

Core attributes:

Reflects architectural changes by updating the system topology in real time.
Exposes structured relationship data to AI.
Supports multi-dimensional views.

2. Cross-domain data fusion

Use EntitySetLink to create cross-domain associations:

Association type	Source entity	Target entity	Relationship type	Business meaning
Version tracing	`ops.service_version`	`organization.code_repo`	`sourced_from`	The service version originates from the code repository.
Release association	`ops.service_version`	`organization.code_release`	`sourced_from`	The service version corresponds to a code release.
Development ownership	`organization.developer`	`ops.server_role`	`manage`	A developer is responsible for a server role.
AI usage	`organization.developer`	`organization.ai_tool`	`use`	A developer uses an AI tool.

3. AI-friendly data structure

Standardized schema design

Consistency: All entities follow uniform field naming and type specifications.
Semantics: Field names and descriptions provide rich business semantics.
Extensibility: Supports dynamic fields and custom properties.

Knowledge graph construction

Named Entity Recognition: Automatically detect and classify business entities.
Relationship extraction: Mine implicit relationships between entities.
Semantic inference: Perform knowledge inference based on the graph structure.

Entity domain design

Organization domain (organization)

Entity type	Purpose	Core fields	Associated relationships
Developer	Manage developer information	Employee ID, name, department, position	Direct report relationships, managed services
Code repository	Manage code repositories	Project ID, project path, project URL	Source of releases
Code release	Manage release records	Build ID, commit ID, release notes	Source repository, associated developers
AI tool	Track AI tool usage statistics	Tool name	Used by developers

O&M domain (ops)

Entity type	Purpose	Core fields	Associated relationships
Cluster	Manage cluster information	Cluster name, region, number of machines	Contains hosts and server roles
Host	Manage host resources	Hostname, IP address, zone	Contained in a cluster, used by a server role
Server role	A service that runs in a cluster	Role name, template information	Contains hosts and versions, developer owner
Service template	Deployment template for a specific service	Template name, description, type	Contains service versions
Service version	A specific version of a service	Template name, commit information, MD5	Originates from code repositories and releases

Relationship modeling design

Contains relationship (contains)

Cluster ──contains──► Host
Cluster ──contains──► Server role
Server role ──contains──► Host
Server role ──contains──► Service version
Service template ──contains──► Service version

Source relationship (sourced_from)

Service version ──sourced_from──► Code repository
Service version ──sourced_from──► Code release
Code release ──sourced_from──► Code repository

Usage and management relationships

Developer ──use──► AI tool
Developer ──manage──► Server role
Developer ──direct──► Developer (direct report relationship)

Service invocation relationship

Server role ──calls──► Server role (inter-service invocation)

Scenarios

1. Analysis of AI coding efficiency improvements

Personnel dimension: Analyze AI tool usage and code submission efficiency by individual and department.
Tool dimension: Compare how different AI tools improve development efficiency.
Project dimension: Evaluate AI-assisted development effectiveness at the project level.

2. End-to-end DevOps process integration

Alert association: Link alerts directly to specific service entities and their owners.
Troubleshooting: Quickly identify problems by using the UI, DoraAI, MCP, and other methods.
Change tracking: Trace from observability data back to specific code changes and releases.
Impact analysis: Assess the potential impact of code changes on online services.

3. End-to-end observability

Developer view: See the services and code that a developer is responsible for.
Service view: Inspect a service's dependencies and runtime status.
Code repository view: Track a repository's deployment status and operational performance.

Value and benefits

Immediate benefits

Unified data: Eliminate data silos and establish a unified data view.
Transparent relationships: Clarify dependencies between system components.
Fast identification: Quickly identify the specific service and owner from an alert.

Mid-term benefits

Intelligent analysis: Perform in-depth association analysis based on the graph structure.
Performance measurement: Quantify how AI tools improve development efficiency.
Process optimization: Identify bottlenecks and areas for improvement in the DevOps process.

Long-term benefits

Knowledge accumulation: Transform experience into a reusable knowledge graph.
Intelligent decision-making: Make intelligent decisions based on historical data and relationship analysis.
Ecosystem expansion: Provide unified data modeling capabilities for more business scenarios.