Cloud-Native Applications in Java电子书

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