Overview
This practice course guides students through CI/CD construction for a monolithic system, microservice transformation, pipeline deployment, Kubernetes-based deployment, and cloud-native feature testing.
Learning Objectives
- Master fundamental software engineering knowledge and theories through intensive engineering practice.
- Apply object-oriented software engineering methods to programming, refactoring, testing, and microservice transformation.
- Use major technologies and tools across the software development process, including continuous integration and delivery.
- Work effectively in teams, fulfill individual responsibilities, and communicate during project practice.
Theory Course Content
Theory teaching builds the conceptual frame for course projects and laboratories, with attention to method selection, artifact quality, engineering evidence, and reflective design decisions.
Embedded in practice guidance
Practice-oriented software engineering review
Provide the theoretical frame needed for the intensive practice: students revisit software process, modularity, testing, delivery automation, microservice boundaries, and cloud-native reliability before applying them in the laboratory.
Topics
- From monolithic architecture to microservice decomposition: business boundaries, data ownership, and interface contracts
- CI/CD principles: source control, build automation, test gates, artifact management, and deployment pipelines
- Containerization and Kubernetes concepts: image, pod, service, deployment, replica, configuration, and scaling
- Cloud-native quality concerns: observability, resilience, degraded service, performance, and rollback
- Engineering evidence: test report, deployment record, pipeline log, performance data, and final defense argument
Class Activities
- Review the original monolithic project and identify modules, dependencies, data coupling, and possible service boundaries.
- Explain why each pipeline stage exists before configuring it in the laboratory.
- Connect performance and failure observations to architecture and deployment decisions.
Learning Outcomes
- Understand the engineering rationale behind CI/CD, containerization, microservice transformation, and cloud-native testing.
- Make decomposition and deployment decisions based on explicit quality goals rather than tool usage alone.
- Use practice artifacts as evidence in midterm inspection, final defense, and written reports.
Experiment Course Content
Laboratory teaching turns the theory modules into concrete engineering artifacts, including models, code, tests, deployment evidence, verification records, and project reports.
Laboratory practice
Part 1: CI/CD pipeline construction and testing for a monolithic system
40 hours
Build a local CI/CD pipeline from the existing codebase to local Kubernetes deployment.
Tasks
- Run local unit testing, project build, containerization, and deployment automatically.
- Containerize frontend, backend, and database separately.
- Deploy the containerized system to local Kubernetes and conduct integration testing.
Deliverables
- CI/CD pipeline configuration
- Container images and deployment manifests
- Unit and integration testing evidence
Laboratory practice
Part 2: Microservice transformation and pipeline deployment
40 hours
Transform the previous monolithic system into a microservice-based and containerized system.
Tasks
- Decompose the system into at least three microservices with clear business boundaries.
- Assign each microservice an independent database and move original table associations behind service interfaces.
- Connect the pipeline to a cloud Git repository and automatically trigger build and deployment.
Deliverables
- Microservice decomposition rationale
- Service code and independent databases
- Automated pipeline and deployment records
Laboratory practice
Part 3: Cloud-native feature testing
Integrated in the 80-hour practice
Verify cloud-native behavior and performance changes through Kubernetes mechanisms and load testing.
Tasks
- Use Deployment and ReplicaSet mechanisms to implement automatic scaling and degraded service.
- Use load-testing tools such as JMeter, Gatling, Locust, or k6 to verify effects.
- Compare stable performance differences with the original monolithic system.
Deliverables
- Load-testing scripts
- Performance comparison evidence
- Final defense materials and project report
Assessment
| Item | Weight | Focus |
|---|---|---|
| Regular attendance | 10% | Attendance is checked in morning and afternoon sessions. |
| Basic tasks | 30% | Completion of required engineering practice tasks. |
| Advanced tasks | 40% | Advanced implementation and engineering quality. |
| Project presentation and report | 20% | Midterm inspection, final defense, deliverables, and written report. |
References and Source
- Lyu Yunxiang. Practical Tutorial on Software Engineering. Tsinghua University Press, 2015.
- Lyu Yunxiang et al. Software Engineering Practical Training Tutorial. Tsinghua University Press, 2016.
- Roger S. Pressman. Software Engineering: A Practitioner's Approach.
- Ian Sommerville. Software Engineering.
Source syllabus: 2065-Basic Practice of Software Engineering-Course Syllabus.pdf