Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
Title Page
Copyright and Credits
Cloud-Native Applications in Java
Dedication
Packt Upsell
Why subscribe?
PacktPub.com
Foreword
Contributors
About the authors
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
Introduction to Cloud-Native
Why go cloud-native?
What is cloud-native?
Lift and shift
Going native
Going serverless
Cloud-native and microservices
The 12-factor app
Microservices-enabling service ecosystem
Microservice adoption
Monolithic transformation
Summary
Writing Your First Cloud-Native Application
Setting up your developer toolbox
Getting an IDE
Setting up internet connectivity
Understanding the development life cycle
Requirements/user stories
Architecture
Design
Testing and development
Building and deployment
Selecting a framework
Dropwizard
Vert.x
Spring Boot
Writing a product service
Creating a Maven project
Writing a Spring Boot application class
Writing service and domain objects
Running the service
Testing the service on the browser
Creating a deployable
Enabling cloud-native behaviors
Externalizing configuration
Metering your services
Service registration and discovery
Running a service registry
Registering a product service
Creating a product client
Seeing the lookup in action
Summary
Designing Your Cloud-Native Application
The trio – REST, HTTP, and JSON
Rise and popularity of the APIs
Role of API gateways
Benefits of an API gateway
Application decoupling
Bounded context/domain-driven design
Classification into up/downstream services
Business events
Microservice identification
Differences between microservices and service-oriented architecture (SOA)
Service granularity
Microservice design guidelines
Design and deployment patterns
Design patterns
Content aggregation patterns
Aggregation by client
API aggregation
Microservice aggregation
Database aggregation
Coordination patterns
Business process management (BPM)
Composite services
Why composite services?
Capabilities for microservices coordination
Coordination models
Asynchronous parallel
Asynchronous sequential
Orchestration using request/response
Collapsing the microservices
Deployment patterns
Multiple services per WAR file
Benefits and trade-offs
Suitability
Service per WAR/EAR
Benefits and trade-offs
Suitability
Service per process
Benefits and trade-offs
Suitability
Service per Docker container
Benefits and trade-offs
Suitability
Service per VM
Benefits and trade-offs
Suitability
Service per host
Benefits and trade-offs
Suitability
Release patterns
Data architecture for microservices
Command Query Responsibility Segregation (CQRS)
Duplicating data
Benefits
Cons
Fit for purpose
The role of security
Summary
Extending Your Cloud-Native Application
Implementing the get services
Simple product table
Running the service
Limitations of traditional databases
Caching
Local cache
Under the hood
Limitations of a local cache
Distributed cache
Applying CQRS to separate data models and services
Materialized views on a relational database
Elasticsearch and a document database
Why not use only a document database or Elasticsearch?
Core product service on a document database
Getting MongoDB ready with test data
Creating the product service
Splitting the services
The product-search service
Getting Elasticsearch ready with test data
Creating the product-search service
Data update services
REST conventions
Inserting a product
Testing
Updating a product
Testing
Deleting a product
Testing
Cache invalidation
Validations and error messages
Format validations
Data validations
Business validations
Exceptions and error messages
Data updates for CQRS
Asynchronous messaging
Starting ActiveMQ
Creating a topic
Golden source update
Service methods
Raising an event on data updates
Using Spring JMSTemplate to send a message
Query model update
Insert, update, and delete methods
Testing the CQRS update scenario end to end
Summary
Testing Cloud-Native Applications
Writing test cases before development
TDD
BDD
Testing patterns
A/B testing
Test doubles
Test Stubs
Mock objects
Mock APIs
Types of testing
Unit testing
Integration testing
Load testing
Regression testing
Ensuring code review and coverage
Testing the Product service
BDD through Cucumber
Why Cucumber?
How does Cucumber work?
Spring Boot Test
Code coverage using JaCoCo
Integrating JaCoCo
Summary
Cloud-Native Application Deployment
Deployment models
Virtualization
PaaS
Containers
Docker
Building Docker images
Eureka server
Product API
Connecting to an external Postgres container
Deployment patterns
Blue-green deployment
Canary deployment
Dark release
Applying CI/CD to automate
Summary
Cloud-Native Application Runtime
The need for a runtime
Implementing runtime reference architecture
Service registry
Configuration server
The server part of the config server
The config client
Refreshing the properties
The microservice frontend
Netflix Zuul
What happens behind the scenes
Running them all at once
Kubernetes – container orchestration
Kubernetes architecture and services
Minikube
Running product service in Kubernetes
Platform as a Service (PaaS)
The case for PaaS
Cloud Foundry
The concept of org, account, and space
The need for implementations of Cloud Foundry
Pivotal Cloud Foundry (PCF)
PCF components
PCF Dev
Installation
Starting PCF Dev
Creating the MySQL service on PCF
Running the product service on PCF Dev
Deploying to Cloud Foundry
Summary
Platform Deployment – AWS
AWS platform
AWS platform deployment options
Deploying Spring Boot API to Beanstalk
Deploying a runnable JAR
Deploying Docker containers
Deploying Spring Boot App to the Elastic Container Service
Deploying to AWS Lambda
Summary
Platform Deployment – Azure
Azure platform
Azure platform deployment options
Deploying Spring Boot API to Azure App Service
Deploying Docker containers to Azure Container Service
Deploying Spring Boot API to Azure Service Fabric
Basic environment setup
Packaging the product API application
Starting the Service Fabric cluster
Deploying the product API application to the Service Fabric cluster
Connecting to the local cluster
Connecting to the Service Fabric party cluster
Azure cloud functions
Environment setup
Creating a new Java functions project
Building and running the Java function
Diving into code
Summary
As a Service Integration
XaaS
Key design concerns when building XaaS
Integration with third-party APIs
Summary
API Design Best Practices
API design concerns
API resource identification
System API
Process API
Channel API
API design guidelines
Naming and associations
Base URLs for a resource
Handling errors
Versioning
Pagination
Attributes
Data formats
Client support for limited HTTP methods
Authentication and authorization
Endpoint redirection
Content negotiation
Secure
API modeling
Open API
RESTful API Modeling Language (RAML)
API gateway deployment models
Summary
Digital Transformation
Application portfolio rationalization
Portfolio analysis – business and technical parameters
Retire
Retain
Consolidate
Transform
Monolithic application to distributed cloud-native application
Transformation of a monolithic application to a distributed application
Customer journey mapping to domain-driven design
Defining the architecture runway
Developer build
Breaking the monolithic application
Bringing it all together
Building your own platform services (control versus delegation)
Summary
Other Books You May Enjoy
Leave a review - let other readers know what you think
← Prev
Back
Next →
← Prev
Back
Next →