By Mr. Pervez Kazmi,Chief, Software Architecture & Agile Programme

1. Designing software to make
the most of cloud platforms
#ISSLearningDay2018
Mr. Pervez Kazmi, NUS-ISS
13 July 2018

2. Topics
• Importance of the Cloud in IT
• What is Cloud-Native software?
• Designing Cloud-Native software
#ISSLearningDay2018

3. Reasons for the Cloud’s importance
• Innovate faster and cost-effectively: experiment fast at low cost
• Reduce time-to-market: improved developer productivity
• Reduce cost: pay only for services used
• Improve agility and responsiveness to change
• Get away from setting up and managing infrastructure
• Scale services automatically to meet demand
#ISSLearningDay2018

4. Enterprises, including DBS Bank, are
moving to the Cloud
#ISSLearningDay2018
https://www.dbs.com/investorday/index.html

5. Capitalizing on the Cloud
• Cloud-first strategy for new applications; possible migration to the
cloud for existing applications
• Deliver value early and often: adopt DevOps practices
• Build applications to exploit the cloud: different from applications that
just run in the cloud
• Utilise Platform-as-a-Service (PaaS) development services
- Cloud-dependent, e.g., AWS, Azure, GCP, etc.
- Cloud-independent, e.g., CloudFoundry, Pivotal CloudFoundry, etc.
• Adopt Infrastructure As Code services
- API-based creation and management of infrastructures: no hardware!
- Tools: Chef, Puppet, Ansible, AWS CloudFormation, etc.
#ISSLearningDay2018

6. What is Cloud-Native software?
• Software applications that are
built in the cloud and for the
cloud
• Maximize the benefits of Cloud
• Evolution in application:
- Architecture
- Design
- Development
- Deployment
- Maintenance
#ISSLearningDay2018

7. Microservices, DevOps, Containers
and the Cloud – great synergy
#ISSLearningDay2018

8. Characteristics of good Cloud-Native
Applications
• Effective use of shared resources
• Frictionless application life cycle management
• High scalability
• High availability: auto-healing and auto-repair
• High agility in enhancing functionality at low risk
• Uninterrupted operation
• Instrumentation for management, monitoring, security and billing
#ISSLearningDay2018

9. Changes are needed to fully benefit from
the Cloud
#ISSLearningDay2018
Source: Oracle - https://www.slideshare.net/KellyGoetsch/oracle-building-cloud-native-
applications

10. Service-Based Architecture for Cloud-
Native Applications
• Service-oriented architecture:
- Functions are exposed as services, logical
separation
• Service-oriented integration:
- Loose coupling of the provider and consumers
- Open standards: REST and/or SOAP over HTTP(s)
• Microservices application architecture
- Maximizes agility
- Functionality exposed and consumed via REST
APIs
- Completely autonomous and can be revised,
rewritten, deployed, and scaled independently
- Often deployed in Docker containers
#ISSLearningDay2018

11. Cloud-Native - application architecture
evolution
#ISSLearningDay2018

12. Benefits of a microservices architecture
• Create software efficiently:
- Build business differentiating
capabilities
- Acquire non-differentiating
capabilities
• Functionality-based
teams
• Easier to evolve
• Flexible scaling
#ISSLearningDay2018
Source: Martin Fowler - https://martinfowler.com/articles/microservices.html
Microservices Resource Guide: https://martinfowler.com/microservices/

13. Cloud-Native - adopt Microservices with
care
• Microservices are very helpful for Cloud Native but must be
used correctly
• Data exchange between microservices must be through APIs or
messaging
- Not by accessing data stores directly
• Latency will be a concern
- High-speed messaging may be needed for synchronous calls between
microservices
- REST + HTTP may be too slow
#ISSLearningDay2018

14. Cloud-Native - Business Logic Tier must
be stateless for auto-scaling
#ISSLearningDay2018

15. Containers are aligned with Cloud-
Native
• Application portability supports wide
range of environments
• Automation and integration with CI/CD
and DevOps workflows
• Quick to instantiate and iterate,
shortening feedback loops
• Stateless nature aligns with scale-out
designs
#ISSLearningDay2018

16. What is a container?
• Standardized packaging of software,
dependencies and settings
• Lightweight, stand-alone package
• Isolates apps (or microservices) from
each other
• Containerized software runs the same
• Portable across machines and OSs
• Docker is the leading standard, widely
supported, including on cloud
#ISSLearningDay2018
Containers are an
abstraction at the app
layer that packages code
and dependencies
together.
Containers and microservices have great synergy!

17. Cloud-Native - No hard-coded Host
Names, IPs, etc.
#ISSLearningDay2018

18. Cloud-Native - role of an API Gateway
#ISSLearningDay2018

19. Cloud-Native - Distribute application
front- and back-ends suitably
#ISSLearningDay2018

20. Cloud-Native - choose the best
technologies per Microservice
#ISSLearningDay2018

21. Cloud-Native - build automatically on
code change
#ISSLearningDay2018

22. Cloud-Native - test everything, all the
time, automated
#ISSLearningDay2018

23. Cloud-Native - continuously deploy
tested functionality
#ISSLearningDay2018

24. Cloud-Native – automatic healing and
repair
#ISSLearningDay2018

25. Twelve-Factor Applications: Best
practices for Cloud-Native applications
• Provides lessons learnt from building many
Cloud Native applications
• Contains 12 factors that describe how to
design Cloud Native applications
• The Appendix provides a summary
#ISSLearningDay2018
Source: https://12factor.net/

26. Cloud-Native on AWS: Typical
Deployment Architecture
• The back-end
(worker)
functionality will
utilise microservices
in containers
• Loose coupling via
queues at the back-
end
• Auto-scaling, self-
tuning, self-healing
• The application will
run in multiple
Availability Zones
(and possibly
multiple regions)
#ISSLearningDay2018

27. Appendix
#ISSLearningDay2018

28. The 12-factor app – 1 / 4
• Single codebase:
• The application must have one codebase, tracked in revision control for
every application (read: microservice) that can be deployed multiple
times to differenct environments).
• Dependencies:
• The application must explicitly declare its code dependencies and add
them to the application or microservice. The dependencies are
packaged as part of a microservice.
• Configuration:
• The application configuration data is moved out of the application or
microservice.
#ISSLearningDay2018

29. The 12-factor app – 2 / 4
• Backing services:
• All external resources, access should be an addressable URL.
• Build, release and run:
• Treated as separate steps.
• Pick the relevant configuration to run the process based on the
environment (development, testing, staging, or production).
• Processes:
• A microservice has a shared-nothing model (stateless processes)
allowing seamless scalability and load balancing.
#ISSLearningDay2018

30. The 12-factor app – 3 / 4
• Port binding:
• A microservice’s services are exposed as port bindings.
• Concurrency:
• The microservice process is scaled out by adding more processes to
the environment.
• Within the microservice process, the reactive model can be used to
optimize resource utilization.
• Disposability:
• Immutable for faster boot-up times and to maximize robustness.
#ISSLearningDay2018

31. The 12-factor app – 4 / 4
• Dev/prod parity:
• The environments across the application life cycle - DEV, TEST,
STAGING, and PROD - are kept as similar as possible.
• Logs:
• Logs are treated as event streams and pushed out to a log aggregator.
• Admin processes:
• Microservice instances are long-running processes that continue
unless they are terminated or replaced with newer versions.
#ISSLearningDay2018

32. Thank You!
pervez.kazmi@nus.edu.sg
#ISSLearningDay2018