• ES Español
• EN English

5.52. Software Architecture and DevOps for Cloud Software (Elective)

5.52.1. Justification ↑ Back to top

Modern software design requires combining solid architectural principles with agile continuous delivery practices and cloud operations. This course integrates three areas that are inseparable in today's industry: software architecture, DevOps, and cloud computing.

Students will learn to design systems at scale using well-established architectural patterns, to automate build, test, and deployment cycles through CI/CD pipelines, and to provision and operate infrastructure on public cloud platforms using containers, orchestration, and infrastructure-as-code tools.

The course places special emphasis on the reliability and observability of distributed systems, covering metrics, distributed traces, error budgets, and site reliability engineering (SRE) practices as applied in high-performing technology organizations.

5.52.2. Generales Goals ↑ Back to top

1. Design scalable and maintainable software systems by applying modern architectural patterns.
2. Implement continuous integration and continuous delivery (CI/CD) pipelines to accelerate and secure the software lifecycle.
3. Deploy and manage containerized applications on public cloud platforms using industry-standard tools.
4. Provision cloud infrastructure in a reproducible and versioned manner through infrastructure as code (IaC).
5. Apply observability and SRE practices to ensure the reliability of systems in production.

5.52.3. Contribution to Outcomes ↑ Back to top

AG-C09) Design and Development of Solutions: Designs, implements, and evaluates solutions for complex computing problems. (Assessment)

AG-C11) Use of Tools: Applies modern computing tools in problem solving. (Assessment)

AG-C12) Applies computer science theory and software development fundamentals to produce computer-based solutions. (Usage)

5.52.4. Content ↑ Back to top

5.52.4.1. Principles and Software Architecture (8 hours) [Skills AG-C09,AG-C12] ↑ Back to top

Bibliography: (Bass et al., 2021; Richards and Ford, 2020)

Topics

1. System design principles. System Reliability
2. Levels of abstraction (e.g., architectural design and detailed design)
3. Separation of concerns
4. Information hiding
5. Coupling and cohesion enumerate
6. Software architecture. System Reliability
7. Design paradigms
8. Top-down functional decomposition/layered design
9. Data-oriented architecture
10. Object-oriented analysis and design
11. Event-driven design enumerate
12. Standard architectures (e.g., client-server and microservice architectures including REST discussions, n-layer, pipes-and-filters, Model View Controller)
13. Identifying component boundaries and dependencies enumerate
14. Programming in the large vs programming in the small. System Reliability
15. Structural and behavioral models of software designs
16. Design modeling, for instance with class diagrams, entity relationship diagrams, or sequence diagrams
17. API design principles
18. Consistency
19. Consistent APIs are easier to learn and less error-prone
20. Consistency is both internal (between different portions of the API) and external (following common API patterns) enumerate
21. Composability
22. Documenting contracts
23. API operations should describe their effect on the system, but not generally their implementation
24. Preconditions, postconditions, and invariants enumerate
25. Expandability
26. Error reporting
27. Errors should be clear, predictable, and actionable
28. Input that does not match the contract should produce an error
29. Errors that can be reliably managed without reporting should be managed enumerate enumerate

Learning Outcomes

1. Identify the standard software architecture of a given high-level design [Analyze]
2. Identify the dependencies among a set of software components in an architectural design [Analyze]
3. Select and use an appropriate design paradigm to design a simple software system and explain how system design principles have been applied in this design [Evaluate]
4. Translate a natural language software design into class diagrams [Translate]

5.52.4.2. Software Design Quality and Evaluation (8 hours) [Skills AG-C09,AG-C12] ↑ Back to top

Bibliography: (Richards and Ford, 2020)

Topics

1. Evaluating design tradeoffs (e.g., efficiency vs reliability, security vs usability)
2. Architectural styles: layered, event-driven, microkernel, service-oriented, pipeline.
3. Quality attributes: availability, scalability, performance, security, maintainability.
4. Requirement traceability
5. Understanding which requirements are satisfied by a design enumerate
6. Measurement and analysis of design quality

Learning Outcomes

1. Contrast two software designs across different qualities, such as efficiency or usability [Contrast]
2. Identify which requirements are satisfied by a provided software design [Analyze]
3. Adapt a flawed system design to better follow principles such as separation of concerns or information hiding [Create]
4. Select the most appropriate architectural style given the quality attributes required by a system. [Assessment]

5.52.4.3. API Design and Modeling (6 hours) [Skills AG-C09,AG-C11] ↑ Back to top

Bibliography: (Newman, 2021)

Topics

1. Microservices principles: cohesion, loose coupling, and service boundaries.
2. Monolith decomposition: domain-driven design (DDD).
3. API design principles
4. Consistency
5. Consistent APIs are easier to learn and less error-prone
6. Consistency is both internal (between different portions of the API) and external (following common API patterns) enumerate
7. Composability
8. Documenting contracts
9. API operations should describe their effect on the system, but not generally their implementation
10. Preconditions, postconditions, and invariants enumerate
11. Expandability
12. Error reporting
13. Errors should be clear, predictable, and actionable
14. Input that does not match the contract should produce an error
15. Errors that can be reliably managed without reporting should be managed enumerate enumerate
16. API Gateway and service mesh.
17. Resilience patterns: Circuit Breaker, Retry, Bulkhead, Timeout.
18. Data Stores
19. Cooperatively maintained data structures implementing maps and related ADTs
20. Varieties: Owned, shared, sharded, replicated, immutable, versioned enumerate

Learning Outcomes

1. Design an API for a single component of a large software system, including identifying and documenting each operation's invariants, contract, and error conditions [Design]
2. Evaluate an API description in terms of consistency, composability, and expandability [Evaluate]
3. Design a microservices-based system by decomposing a monolithic application into independent services. [Usage]
4. Apply resilience patterns to tolerate failures in distributed systems. [Usage]

5.52.4.4. Virtualization (6 hours) [Skills AG-C11,AG-C12] ↑ Back to top

Bibliography: (Burns et al., 2022)

Topics

1. Containers and their comparison to virtual machines.
2. Types of virtualizations (including hardware/software, OS, server, service, network). See also: Latency, Cache and Memory Hierarchy , Virtualization and Isolation
3. Portable virtualization; emulation vs isolation. See also: Latency, Cache and Memory Hierarchy , Virtualization and Isolation
4. Virtual machines and container escapes, dangers from a security perspective. See also: Security Design and Controls Engineering , Threat Analysis and Security Engineering , Trusted Computing and Privacy Engineering
5. Dockerfile: best practices for building efficient and secure images.
6. Multi-container application composition with docker-compose.

Learning Outcomes

1. Explain the difference between emulation and isolation [Explain]
2. Evaluate virtualization tradeoffs [Evaluate]
3. Build and deploy containerized applications using Docker. [Usage]
4. Apply security best practices when building Docker images. [Usage]

5.52.4.5. Coordination (6 hours) [Skills AG-C09,AG-C11] ↑ Back to top

Bibliography: (Burns et al., 2022)

Topics

1. Kubernetes architecture: control plane and worker nodes.
2. Core objects: Pods, Deployments, Services, ConfigMaps, Secrets.
3. Horizontal Pod Autoscaling (HPA) and self-healing.
4. Dependencies
5. Initiation or progress of one activity may be dependent on other activities, so as to avoid race conditions, ensure termination, or meet other requirements
6. Ensuring progress by avoiding dependency cycles, using monotonic conditions, removing inessential dependencies enumerate
7. Package management with Helm.

Learning Outcomes

1. Deploy and manage containerized applications on a Kubernetes cluster. [Usage]
2. Configure auto-scaling and self-healing for cloud-native workloads. [Usage]
3. Modify a concurrent system to use a more scalable, reliable, or available data store [Create]

5.52.4.6. Version Control and CI/CD (6 hours) [Skills AG-C11,AG-C12] ↑ Back to top

Bibliography: (Kim et al., 2021)

Topics

1. Software configuration management and version control: Software Development Practices
2. Configuration in version control, reproducible builds/configuration.
3. Version control branching strategies. Development branches vs release branches. Trunk-based development.
4. Merging/rebasing strategies, when relevant. enumerate
5. Release management.
6. Software process automation:
7. Build systems - the value of fast, hermetic, reproducible builds, compare/contrast approaches to building a project.
8. Continuous Integration (CI) - the use of automation and automated tests to do preliminary validation that the current head/trunk revision builds and passes (basic) tests.
9. Continuous Deployment (CD) - the use of automation to automatically release every change that passes the automated tests to the production environment, ensuring frequent and reliable deliveries.
10. Dependency management - updating external/upstream dependencies, package management, SemVer. enumerate
11. Testing tools including static and dynamic analysis tools. Software Development Practices , Information Flow and Non-Interference , Injection and Input Validation , Memory Safety and Types , Malware Analysis and Advanced Security
12. Tool integration concepts and mechanisms. Software Development Practices
13. DevOps culture: flow, feedback, and continuous learning.

Learning Outcomes

1. Describe the difference between centralized and distributed software configuration management [Describe]
2. Describe how version control can be used to help manage software release management [Describe]
3. Understand the use of CI/CD systems as a ground-truth for the state of the team's shared code (build and test success) [Explain]
4. Demonstrate the capability to use software tools in support of the development of a software product of medium size [Demonstrate]

5.52.4.7. Version Control and CI/CD (6 hours) [Skills AG-C11,AG-C12] ↑ Back to top

Bibliography: (Morris, 2021; Kim et al., 2021)

Topics

1. IaC principles: reproducibility, idempotency, and infrastructure versioning.
2. Declarative vs.\ imperative approaches.
3. Terraform: providers, resources, modules, and state management.
4. Cloud-native IaC tools: AWS CloudFormation, Azure ARM Templates, GCP Deployment Manager.
5. Software configuration management and version control: Software Development Practices
6. Configuration in version control, reproducible builds/configuration.
7. Version control branching strategies. Development branches vs release branches. Trunk-based development.
8. Merging/rebasing strategies, when relevant. enumerate

Learning Outcomes

1. Write and apply Terraform configurations to provision cloud infrastructure. [Usage]
2. Identify configuration items and use a source code control tool in a small team-based project [Analyze]
3. Compare IaC tools based on their state management and modularity capabilities. [Assessment]

5.52.4.8. Networked Applications (6 hours) [Skills AG-C09,AG-C11] ↑ Back to top

Bibliography: (Kim et al., 2021; Burns et al., 2022)

Topics

1. Cloud service models: IaaS, PaaS, SaaS, FaaS.
2. Distributed application paradigms (e.g., client/server, peer-to-peer, cloud, edge, and fog). See also: Communication , Coordination
3. Major providers: AWS, Google Cloud, Azure — core services.
4. Compute services: virtual machines, serverless functions, managed containers.
5. Storage services: object, block, and managed databases.
6. Cloud networking: VPCs, load balancers, CDN.

Learning Outcomes

1. Analyze the needs of specific networked application demands [Analyze]
2. Compare IaaS, PaaS, SaaS, and FaaS models to select the most appropriate one for a given architecture. [Assessment]
3. Design a cloud-native application using managed services from a major cloud provider. [Usage]

5.52.4.9. Reliability Engineering (6 hours) [Skills AG-C11,AG-C12] ↑ Back to top

Bibliography: (Kim et al., 2021)

Topics

1. Measurement-based analysis of software reliability - telemetry, monitoring and alerting, dashboards, release qualification metrics, etc.
2. The three pillars of observability: metrics, logs, and distributed traces.
3. Distributed tracing and correlation identifiers.
4. Software reliability engineering practices - including reviews, testing, practical model checking
5. Alerting strategies and on-call practices.

Learning Outcomes

1. Describe how to determine the level of reliability required by a software system [Describe]
2. Identify methods that will lead to the realization of a software architecture that achieves a specified level of reliability [Analyze]
3. Implement observability in a cloud application using metrics, logs, and distributed traces. [Usage]

5.52.4.10. System Reliability (6 hours) [Skills AG-C09,AG-C12] ↑ Back to top

Bibliography: (Kim et al., 2021)

Topics

1. Concept of reliability as probability of failure or mean time between failures, and faults as cause of failures
2. Compare the "error budget'' approach to reliability with the "error-free'' approach and identify domains where each is relevant.
3. Software fault tolerance techniques and models
4. Contextual differences in fault tolerance (e.g., crashing a flight critical system is strongly avoided, crashing a data processing system before corrupt data is written to storage is highly valuable) enumerate
5. Reliability through redundancy:
6. check and retry Reliability Support , Fault tolerance
7. redundant encoding (error correction codes, CRC, FEC, RAID) Memory Hierarchy , Distributed Databases/Cloud Computing , Reliability Support
8. duplication/mirroring/replicas Distributed Databases/Cloud Computing enumerate
9. Software reliability, system reliability and failure behavior
10. Service Level Indicators (SLI), Objectives (SLO), and Agreements (SLA).

Learning Outcomes

1. Identify ways to apply redundancy to achieve fault tolerance [Analyze]
2. Identify single-point-of-failure (SPF) dependencies in a system design [Analyze]
3. Explain the problems that exist in achieving very high levels of reliability [Explain]
4. Define SLIs, SLOs, and error budgets for a service in production. [Usage]

5.52.5. Bibliography ↑ Back to top

Bass, L., Clements, P., and Kazman, R. (2021). Software Architecture in Practice. Addison-Wesley Professional, 4th edition.

Richards, M. and Ford, N. (2020). Fundamentals of Software Architecture: An Engineering Approach. O'Reilly Media, 1st edition.

Newman, S. (2021). Building Microservices: Designing Fine-Grained Systems. O'Reilly Media, 2nd edition.

Burns, B., Beda, J., Hightower, K., and Evenson, L. (2022). Kubernetes: Up and Running. O'Reilly Media, 3rd edition.

Kim, G., Humble, J., Debois, P., Willis, J., and Forsgren, N. (2021). The DevOps Handbook: How to Create World-Class Agility, Reliability, and Security in Technology Organizations. IT Revolution Press, 2nd edition.

Morris, K. (2021). Infrastructure as Code: Dynamic Systems for the Cloud Age. O'Reilly Media, 2nd edition.