Beginning Cloud Native Development with MicroProfile, Jakarta EE, and Kubernetes: Java DevOps for Building and Deploying Microservices-based Applications

Table of Contents
About the Author
About the Technical Reviewers
Acknowledgments
Introduction
Chapter 1: Introduction to Cloud Computing
	Introduction to Cloud Computing
		Examples of Cloud Computing
		Benefits of Cloud Computing
		Essential Characteristics of Cloud Computing
			On-Demand Self-Service
			Broad Network Access
			Resource Pooling
			Rapid Elasticity
			Measured Service
	Types of Cloud Computing Based on Deployment Models
		Public Cloud
			Benefits of a Public Cloud
			Drawbacks of a Public Cloud
		Community Cloud
			Benefits of a Community Cloud
			Limitations of a Community Cloud
		Private Cloud
			Benefits of a Private Cloud
			Disadvantages of a Private Cloud
		Hybrid Cloud
			Benefits of a Hybrid Cloud
			Drawbacks of a Hybrid Cloud
	Service Models of Cloud Computing
		Software as a Service (SaaS)
			Benefits
			Disadvantages
			How It Works
		Platform as a Service (PaaS)
			Benefits of PaaS
			Limitations of PaaS
		Infrastructure as a Service (IaaS)
			Benefits of IaaS
			Limitations of IaaS
	The Role of Java in Cloud Computing
	The Evolution of Cloud Computing
	Summary
Chapter 2: Cloud-Native Application Development
	What Is Cloud-Native?
		Characteristics of Cloud-Native Applications
		Examples of Cloud-Native Applications
	Benefits of Cloud-Native Applications
		Drawbacks of Using Cloud-Native Applications
	Cloud-Native Applications vs. Traditional Applications
	Cloud-Native Application Development
	Managed Services for Java-Based Applications
		Examples of Cloud-Native Application Development
		Cloud-Native Application Development Is the Future
		Phases of Cloud-Native Application Development
			Continuous Integration/Continuous Delivery (CI/CD)
			Infrastructure as Code (IaC)
			Microservices Architecture
			Containerization
			Serverless Computing
			API Management
			Security
			DevOps Culture Shift
			Observability
			Best Practices for Observability
	Summary
Chapter 3: Setting Up Your Development Environment
	Prerequisites
		Hardware Requirements
			Operating Systems
			Software Dependencies
		Installing Java Development Kit (JDK)
	Using Maven
		Installing Maven
	Git
		Installing Git
		Creating a GitHub Account
		Creating a GitHub Repository
		Pushing Code to a GitHub Repository
	Using Docker
		Benefits of Using Docker
		Installing Docker
		Docker Hub
			Creating a Docker Hub Account
	Using Kubernetes
		Installing Kubernetes
		Configuring Docker for Kubernetes
		Creating a Kubernetes Cluster
	Using Zipkin
		Installing Zipkin
	Integrated Development Environments (IDE)
	Summary
Chapter 4: Building RESTful Web Services
	REST: An Architectural Style for Building Web Services
	Introduction to Open Liberty Runtime
		Key Features of the Open Liberty Application Server
		Downloading and Installing Open Liberty
		Starting the Open Liberty Server
		Printing a List of Features on the Open Liberty Server
		Creating a Server Instance
		Stopping the Open Liberty Server
		Configuring the Server
		Creating a RESTful Web Service in Open Liberty
			Exploring the Project Structure
			Understanding the Maven pom.xml File for the Open Liberty Project
			Running an Existing Jakarta EE Project in Open Liberty
			The server.xml Configuration File
			Developing a REST Application
			Using Open Liberty Plugin for IntelliJ IDEA Ultimate Edition
				Installing the Open Liberty Plugin in IntelliJ IDEA Ultimate Edition
		Creating a RESTful API
			Creating a Resource Class
			Creating a Service Class
			Writing Unit Tests for the Service Class
			Updating Product Data Using REST APIs
				Creating a Product
				Updating a Product
				Deleting a Product
	Summary
Chapter 5: Microservices Architecture
	Vertical Scaling
	Horizontal Scaling
		Vertical vs. Horizontal Scaling
	History of Service-Based Architecture
	Types of Service-Based Architectures
		Service-Oriented Architecture (SOA)
		What Is a Web Service?
	What Is SOAP?
		What Is REST?
		REST vs. SOAP
	The Monolithic Architecture
		Evolution of the Microservices Architecture
			Microservices Architectures
		Benefits of Microservices Architectures
	Drawbacks of Microservices Architectures
		Design Considerations
		Using Microservices in Cloud-Native Applications
		Cloud-Native Twelve-Factor Applications
	What Is a Virtual Machine?
	What Are Containers?
		What Are Container-Based Applications?
		What Are Serverless Applications?
		Where Is Serverless Computing Used?
		Benefits of Serverless Computing
		Drawbacks of Serverless Computing
		Popular Serverless Platforms
	Main Components of a Serverless Computing Platform
		Serverless Applications vs. Containers
			Ease of Development
				Container-Based Applications
				Serverless Applications
			Ease of Deployment
				Container-Based Applications
				Serverless Applications
			Cloud Computing Cost
				Container-Based Applications
				Serverless Applications
			Portability
				Container-Based Applications
				Serverless Applications
			Scalability and Performance
				Container-Based Applications
				Serverless Applications
			Security Considerations
				Serverless Applications
				Container-Based Applications
	Microservice Deployment Patterns
		Key Considerations
		Microservices Deployment Strategies and Patterns
			Canary Deployment
				Pitfalls of Canary Deployment
			Blue-Green Deployment
				Pitfalls of the Blue-Green Deployment Strategy
			Dark Launching
				Pitfalls of Dark Launching
			Staged Release
				Pitfalls of Staged Release
		Microservices Management
	Summary
Chapter 6: The Eclipse MicroProfile Framework
	What Is the Eclipse MicroProfile Framework?
		Layers of Functionality in MicroProfile
		Popular Implementations of the Eclipse MicroProfile Framework
		MicroProfile Config
			Maven Dependency
			Enabling MicroProfile Config in Open Liberty
			Working with MicroProfile Config
			Defining the Config Property
			Testing the Config Component
			Creating a ConfigSource
			Registering a ConfigSource
			Accessing Configuration Data
			Accessing Configuration Metadata
			Specifying Default Values for the Config Property
			Type Conversion in a ConfigProperty
			Using an Optional ConfigProperty
			Converting Configuration Data Into a POJO
			Programmatically Looking Up Configuration Data
	The MicroProfile Health Check Specification
	The MicroProfile Fault Tolerance Component
		Key Features of the Fault Tolerance Component
		Fault Tolerance API
	Summary
Chapter 7: MicroProfile Framework – Part 2
	The MicroProfile Metrics Specification
		Types of Metrics
		Metrics Components
		Metrics Annotations
		Maven Dependency
		Tracking Response Time Using @Timed
		Tracking the Number of Invocations
		Tracking Memory Usage
		MetricRegistry
		Creating Custom Metrics
			Exposing Metrics
				JMX
				JSON
				Prometheus
	Using Open Tracing
		Distributed Tracing
		How Does It Work?
			MicroProfile OpenTracing Within a Jakarta RESTful Web Service
			Explicitly Enabling OpenTracing
			Injecting a Custom Tracer Object
	Using the Jakarta RESTful Web Service
	Using the MicroProfile OpenAPI Specification
		OpenAPI
		Capabilities of the MicroProfile OpenAPI Specification
		Generating OpenAPI Documents
		Using the MicroProfile OpenAPI in Your Project
		MicroProfile OpenAPI Annotations
	Summary
Chapter 8: MicroProfile JSON Web Tokens and Jakarta Security
	Security Best Practices for Microservices
	What Is a JSON Web Token (JWT)?
		Use Cases for JSON Web Tokens
		Authentication
		Authorization
		Session Information
		Claims-Based Identity
		Information Exchange
		Federation
	Creating and Signing a JWT
		Testing the Application
	Verifying and Validating a JWT
	Using JWT in a Microservice Environment
		Securing a RESTful Application
		Securing a REST Resource
		The @RolesAllowed Annotation
		The @Claim Annotation
		The @HeaderParam Annotation
	Configuring a JWK Set or PEM-Encoded Public Key
		Public Key Cryptography Standards #8 in PEM Format
		JSON Web Key (JWK)
		JSON Web Key Set (JWKS)
	The Jakarta EE Security Specification
		Securing a Servlet Using Jakarta Security
	The MicroProfile REST Client
		The @RegisterClient Annotation
		Configuring Your REST Client
		REST Client Interface
		Documenting RESTful APIs Using MicroProfile OpenAPI
		What Is the OpenAPI Specification?
		What Is MicroProfile OpenAPI?
			Using the MicroProfile OpenAPI to Document a REST API
			Viewing the Generated Documentation
	Summary
Chapter 9: Containerizing Microservices Using Kubernetes
	What Are Containers?
	Why Use Containers?
	What Is Container Orchestration?
		The Benefits of Using Container Orchestration
	Understanding Kubernetes Terminology
	The Key Features of Kubernetes
	Using Kubernetes
	Using Docker Containers
		Running a MicroProfile Application in Docker
		Pushing the Docker Image to Docker Hub
		Scaling Your Deployment
	Summary
Appendix A: Introduction to Maven
	Features of Maven
	Maven Lifecycle
	Benefits of Maven
	How Does Maven Benefit the Development Process?
		The Maven Architecture
			What Is a Maven Repository?
			Using Maven to Create a Java Project
			Using Maven in Your Project
		Useful Maven Commands
			What Is the Difference Between a Snapshot and a Release?
Appendix B: Creating an Open Liberty Project Using Maven
	Generating a Web Project Using Maven
Appendix C: Installing Open Liberty Tools
Index