tencentblueking/bk-ci
Overview
This skill describes the global architecture of BK-CI, a pipeline-centered continuous integration platform. It presents a panoramic view of modules, execution flow, data flows, and core concepts to help readers quickly grasp how components collaborate. Use it as the primary reference when you need a system-wide mental model before diving into module-level details.
How this skill works
The document outlines a five-layer system: User, Gateway, Microservice, Build Machine, and Resource layers, and maps core modules (Process, Dispatch, Worker, Agent, Store, Auth, etc.) to responsibilities. It traces the full pipeline execution lifecycle from trigger to build end, explains responsibility-chain scheduling (Stage/Container/Task), and details Worker/Agent interactions and event-driven non-blocking coordination. Key code entry points and database task patterns are highlighted to aid cross-module development and debugging.
When to use it
- When you need an overall system view before starting cross-module development.
- When tracing complex runtime behavior across services and build machines.
- When planning architecture changes, refactors, or new pipeline features.
- When deciding which module should own a new capability (auth, dispatch, store, etc.).
- When onboarding engineers to BK-CI or preparing operational runbooks.
Best practices
- Start with the global flow: trigger → engine → dispatch → agent → worker → status return.
- Follow the responsibility-chain pattern for stage/container control to keep scheduling predictable.
- Design new features to fit the existing layer responsibilities (microservice vs build-machine).
- Prefer event-driven, non-blocking interactions for cross-service coordination and scalability.
- Use the documented key entry points and APIs (claimTask, completeTask, jobStarted) for Worker integration.
Example use cases
- Implementing a new pipeline plugin that requires Worker runtime and Store registration.
- Changing dispatch strategy to optimize build machine allocation and quota management.
- Adding an OpenAPI-driven remote trigger integration for third-party CI/CD automation.
- Investigating a failed pipeline by tracing task status from Worker back to PipelineBuildFacadeService.
- Designing RBAC changes that impact pipeline triggers and execution permissions.
FAQ
Start with Process (engine) for orchestration, Dispatch for allocation, Agent/Worker for execution, then check Log/Notify for artifacts and alerts.
How does BK-CI handle scalability for many concurrent pipelines?
It uses event-driven scheduling, responsibility chains to decouple steps, and distributed Dispatch/Agent workers so build load spreads across build machines and services.
24 skills
This skill helps you understand BK-CI global architecture, orchestrate cross-module development, and plan architectural design across pipelines, modules, and
This skill helps you leverage utility components to implement JWT authentication, expression parsing, thread pool utilities, and chain of responsibility in
This skill helps you design and navigate a Kotlin project management module, covering project lifecycle, membership, configuration, and governance.
This skill helps standardize git commit messages, branch naming, and PR readiness to streamline code reviews and issue tracking.
This skill helps you develop Kotlin/Java backend microservices by applying four-layer architecture, dependency injection, and Spring Boot best practices.
This skill guides Vue 2/3 development, Vuex, and routing with best practices for component structure, state management, and API integration.
This skill helps you design well-structured Agent Skills, draft SKILL.md, and validate frontmatter for IDE integrations.
This skill helps you gather business knowledge from external docs, validate with code, and produce reusable Skill documentation efficiently.
This skill helps you manage diverse code repositories, configure webhooks, and handle authorization and triggers across Git, SVN, and GitHub within BK-CI.
This skill helps you manage pipeline templates with versioning, instantiation, and store integration to boost reuse and standardization.
This skill helps you understand and leverage BK-CI's six support modules—Ticket, Environment, Notify, Log, Quality, and OpenAPI—to boost security and
This skill guides Go agent development by detailing architecture, heartbeat, task execution, and dispatch interactions to streamline building agents.
This skill helps you create, configure, and debug blueking pipeline plugins across languages with task.json, inputs, outputs, and release steps.
This skill helps you design and optimize dispatch scheduling for multiple build environments, improving resource allocation and deployment efficiency.
This skill helps you design and optimize a worker-based execution engine, including task dispatch, plugin execution, and log reporting.
This skill orchestrates agent startup, heartbeat, task execution, upgrades, and worker interaction for BK-CI build machines.
This skill helps you convert YAML pipelines to models and back, validate syntax, and implement Pipeline as Code with templates and triggers.
This skill helps you implement microservice infrastructure foundations including conditional config, event-driven architecture, inter-service communication,
This skill helps you understand and work with the BK-CI pipeline core model, enabling you to manage stages, containers, and tasks.
This skill helps you manage pipeline variables across lifecycle and extend their fields, improving configuration, transfer, and debugging efficiency.
This skill provides a concise overview of the Process module architecture, helping you navigate API, engine, and data layers to accelerate pipeline development.
This skill provides cross-cutting backend practices for AOP, distributed locks, retry, validation, monitoring, scheduling, and auditing in Spring Boot.
This skill helps you manage BlueKing pipelines by querying histories, obtaining start parameters, viewing statuses, and safely triggering builds with user
This skill helps you write reliable Kotlin unit tests with JUnit5 and MockK, improving test coverage and promoting TDD practices.
