Architecting Cloud Native Applications
0 likes252 views
The document discusses the evolution and architecture patterns of cloud-native applications, emphasizing the shift from monolithic to microservices architectures. It outlines the pros and cons of various architectural patterns, including SOA, event-driven, and microservices, and highlights key practices for successful cloud-native application design. Furthermore, it identifies challenges in managing microservices and emphasizes the importance of cloud-native apps in enhancing scalability, resiliency, and flexibility.
Architecting Cloud Native Applications
- 1. Architecting Cloud Native Applications Dushan Abeyruwan Director- Solutions Architecture WSO2 Inc Chintana Wilamuna Senior Director - Solutions Architecture WSO2 Inc
- 2. ● Background: Architecture patterns ● Evolution of microservices ● Fundamentals of developing and managing microservices ● Cloud native apps ● Analyzing architecture trade-offs ● Focusing on adding business value ● Practical example Architecture patterns 2
- 4. ● Monolithic ○ Layered ○ Pipes and filters ○ Microkernel ● Distributed ○ Service Oriented (SOA) ○ Event-driven ○ Space based architecture ○ Microservices Architecture patterns 4
- 5. Architecture patterns > Monolithic > Layered 5 Pros Easy to get started for simple projects Separation of concerns Lower complexity and cost at the beginning Cons Harder to scale Deployments and modifications are complex and expensive HA and fault tolerance is harder Image - https://herbertograca.com/2017/08/03/layered-architecture/
- 6. Architecture patterns > Monolithic > Pipes and filters 6 Pros Easy and simple to get started Comparatively higher modularity Easy to reuse components Cons Harder to scale Deployments and modifications are complex and expensive HA and fault tolerance is harder
- 7. Architecture patterns > Monolithic > Microkernel 7 Image - https://www.oreilly.com/library/view/software-architecture-patterns/9781098134280/ch04.html Pros Flexibility in adding dynamic functionality through plugins Plugins can have their own DB / schema (decoupled data architecture) Reduced scope in testing, can be isolated to each plugin Cons The core is still a monolith, harder to scale Deployments and modifications are complex and expensive HA and fault tolerance is harder
- 8. Architecture patterns > Distributed > SOA 8 Pros One of the easiest and simplest distributed architecture models Functionality is isolated and can be dev., test, deploy separately Easy to scale Cons Typically a lot more complexity due to standards A lot more error conditions due to services over network hops Interdependent services can be hard to debug Image - https://en.wikipedia.org/wiki/Service-oriented_architecture
- 9. Architecture patterns > Distributed > Event-driven 9 Pros Asynchronous comms give higher perf. and overall responsiveness Higher flexibility and extensibility Higher reliability - guaranteed delivery patterns Cons Harder to test HA and scalability of brokers are not simple Handling dynamic events is complex Image - https://developer.confluent.io/patterns/event-stream/event-broker/
- 10. Architecture patterns > Distributed > Spaced based architecture 10 Pros Can scale to handle high performance More responsive - Reads/Writes driven off of a cache Decoupled components Cons Complex and difficult testing process Complicated architecture Higher costs to maintain a system with this high complexity Image - https://en.wikipedia.org/wiki/Space-based_architecture
- 11. Architecture patterns > Distributed > Microservices 11 Pros Often with bounded contexts, clear separation of concerns Data isolation Easy to scale Cons Testing and debugging is harder Integration points between services can become harder to manage Increased cost and communication overhead Image - https://microservices.io/patterns/microservices.html
- 12. Evolution from monolith to microservices
- 13. 105 API API API API API API API API API API API 103 102 10 109 1 Cloud Native/ AI IoT Mobile Internet IT Awakening Mainframe Development has exponentially grown more complicated 13 Consumer demand Suppliers disaggregate architecture to meet demand 1970s 1980s 1990s 2000s 2010s 2020+ Monolithic Business Apps. Enterprise Apps. Departmental Apps. SaaS Apps. Private / Public APIs Serverless & Microservices
- 14. Fundamentals of developing and managing microservices
- 15. Design Patterns for Microservices 15 https://www.linkedin.com/pulse/microservices-design-patterns-pranav-kumar-dwivedi/
- 16. Challenges in managing microservices 16 ● Packaging microservices - Containers ● Testing - A/B, Blue-Green, Canary ● Version management ● Configuration management ● Scaling ● Discovering services and endpoints ● Monitoring
- 17. Cloud Native era
- 18. “The cloud native era is transforming how we build and deliver technology, creating more dynamic and immersive digital experiences than ever before.”
- 19. What is Cloud Native? “Cloud-native architecture and technologies are an approach to designing, constructing, and operating workloads that are built in the cloud and take full advantage of the cloud computing model.” 19 Source: https://learn.microsoft.com/en-us/dotnet/architecture/cloud-native/definition https://wso2.com/choreo/resources/building-a-cloud-native-twelve-factor-app-on-choreo-just-write-the-code/
- 20. Cloud Native Application Design Cloud-native architecture harnesses cloud benefits through key practices: ● Microservices: Splits apps into small services for flexible scaling and maintenance. ● Containers/Orchestration: Ensures consistent environments and automates operations with tools like Kubernetes. ● Immutable Infrastructure: Uses replaceable components for reliability, avoiding direct changes. ● Declarative APIs: Defines desired states, ensuring consistent application behavior. ● Stateless Design: Improves scalability and fault tolerance; stores state externally for better load management. Above practices enable resilient, scalable, and manageable cloud applications, optimizing deployment and operations.
- 21. 21
- 22. What is a cloud native application and what are the benefits? ● Cloud native apps are specifically designed and built to run on cloud computing platforms by using technologies that are optimized for the cloud environment. ● These apps gain benefits of the cloud including ⦿ Scalability: Ability to scale up and down as needed ⦿ Resiliency: Can continue to function event if individual components fail ⦿ Flexibility: Can be deployed in any environment and easily integrated with other services and apps ⦿ Faster time-to-market: Modular, containerized architecture makes it easier to develop, test, and deploy new features. ⦿ Cost-effective: You only have to pay for resources that you use 22
- 23. Cloud native app journey ● The business leader aims to deliver awesome digital experiences rapidly. ● Architects and app developers should adopt generic patterns to their use case and unique constraints ● Application developers must understand underlying infrastructure concerns ⦿ DevOps ⦿ GitOps ⦿ CI/CD ⦿ API management ⦿ Analytics & Insights ⦿ Observability and Monitoring ⦿ Security 23
- 24. Typical brown field app transformation Centralized Decentralized 24
- 25. Typical brown field app transformation 25 Decentralized Centralized Cell Based Architecture - https://github.com/wso2/reference-architecture/blob/master/reference-architecture-cell- based.md
- 26. A typical path of a cloud native application ● They face several challenges along the way: ⦿ Challenge 1: Technology complexity ⦿ Challenge 2: Hard to find technical resources ⦿ Challenge 3: Slow to go-to-market ● The organization must now make a decision ⦿ Continue to build a platform on their own ⦿ Buy a ready made platform with all the tools they need 26
- 28. ● Use case - Hotel Reservation System ○ Room reservation ○ Room search ○ Cancel reservation Application Architecture - Analyzing trade-offs 28
- 29. Analyzing trade-offs > Room reservation 29
- 30. Analyzing trade-offs > Room reservation 30
- 31. Trade off analysis at a granular level 31 ● REST vs GraphQL vs gRPC ● Choosing data storage options ○ MySQL, MongoDB, Cassandra ○ GCP - Bigtable, Datastore, Firestore, Spanner, AlloyDB ● Federated GraphQL API for all services of my enterprise
- 32. Still a lot of things left to think about as a architect/developer ● Endpoint management ● Secret management ● Endpoint/API credentials / authentication ● User authentication and authorization ● …
- 33. Tooling make life easy … or does it? 33
- 34. 34 ● Runtime architecture, CI/CD, DevOps, environments, SecOps, configuration management, version management, testing, observability, analytics, and SRE ● New features in development needs re-use of existing code/libs/APIs ● DevOps goes to Blue/Green, etc. ● Self-service and policy-driven ● Zero-trust environment Only digital natives have software manufacturing down to a science; all others are struggling. Developer GitHub Digital Experience B2B Employee Consumer Customer Because manufacturing software in the cloud-native era is very hard You write code. You want to get it to the hands of the customer ASAP.
- 35. Enterprises should focus on engineering applications, not platforms 35
- 36. Focusing on adding business value
- 38. Let’s build it (practical session)
- 39. Demo: Building Hotel Reservation System 39
- 40. “The Luxury Hotel wants to build a reservation system for the public website” Room Search: Users can find rooms by entering check-in and check-out dates and can apply filters based on the guest count. Room Reservation: With requires entering personal details (full name, contact number, email) Update Reservations: Users can change their booking dates Cancel Reservations: Offers an easy option for users to cancel their bookings at any time. Use case 40 Please refer to the instructions guide for more details. https://github.com/wso2con2024/architecture-tutorial
- 43. Thank You!