Cloud-Native Development and Migration to Jakarta EE Transform Your Legacy Java EE Project into a Cloud-Native Application
A pragmatic guide for modernizing your Java EE App with Jakarta EE for cloud-native, serverless excellence Key Features Explore the cargo tracker application, an industry-relevant example that illustrates key Jakarta EE concepts and practices Learn how to transition from Java EE to Jakarta EE to mod...
| Other Authors: | , |
|---|---|
| Format: | eBook |
| Language: | Inglés |
| Published: |
Birmingham, England :
Packt Publishing
[2023]
|
| Edition: | First edition |
| Subjects: | |
| See on Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009781238206719 |
Table of Contents:
- Cover
- Title Page
- Copyright and Credits
- Contributors
- Table of Contents
- Preface
- Part 1: Getting Started with Python
- Chapter 1: The History of Enterprise Java
- What is Java EE, and why was it created?
- Web servers versus application servers
- Web servers
- Application servers
- Profiles to the rescue
- Java EE 5, the first user-friendly version
- The history of key features added in Java EE since version 5
- Java EE 6
- Java EE 7
- Java EE 8
- Summary
- Chapter 2: Introducing the Cargo Tracker Application
- Technical requirements
- What is the Cargo Tracker application?
- Why we chose the Cargo Tracker application
- Installing and running the Cargo Tracker application
- Features of the Cargo Tracker application
- Public Tracking Interface
- Administration Interface
- Mobile Event Logger
- Java EE features used in the Cargo Tracker application
- Enterprise Java Beans
- Persistence (JPA)
- Messaging (JMS)
- Context and Dependency Injection
- Java Service Faces (JSF)
- JAX-RS
- JSON binding
- Transactions
- Batch
- Summary
- Part 2: Modern Jakarta EE
- Chapter 3: Moving from Java EE to Jakarta EE
- Technical requirements
- It's all about namespaces
- Migrating strategies
- Using an open source multiplatform editor
- Sed
- Using a specialized plugin for your IDE
- Upgrading your pom.xml file
- Migrating dependencies
- Upgrading the project
- Upgrading the Payara application server
- Upgrading PrimeFaces
- Red Hat MTA
- Upgrading your application server
- Summary
- Chapter 4: Modernizing Your Application with the Latest Features
- Technical requirements
- The most significant changes to Jakarta EE 10
- Core Profile
- Using UUIDs as keys
- Multi-part form parameters
- Pure Java Jakarta Faces views
- Authenticating with OpenID
- Improved concurrency.
- Adding the first cloud-native feature - resilience
- Adding the second cloud-native feature - monitoring
- Looking at the default metrics of a running system
- Adding metrics to your system
- Using Prometheus and Grafana to visualize the monitoring process
- Setting up Prometheus
- Setting up Docker Compose
- Setting up the Prometheus settings
- Setting up Grafana
- Setting up docker-compose
- Setting up the auto data source
- Setting up the dashboard so that it loads automatically
- Showing Grafana Docker
- Showing the complete Docker file
- Summary
- Chapter 5: Making Your Application Testable
- Technical requirements
- The impact of testing on your migration
- Measuring code coverage of the project
- A word about TDD
- How to create unit tests
- Tools and libraries required for unit testing
- Creating a unit test
- How to create integration tests
- What are integration tests?
- What is Testcontainers?
- Setting up Testcontainers
- Creating an integration test
- Summary
- Part 3: Embracing the Cloud
- Chapter 6: Introduction to Containers and Docker
- Technical requirements
- What are containers?
- How are containers created?
- A brief introduction to Docker
- Installing Docker
- Running a Docker container
- Creating a Docker container
- Building a container
- Running a container
- Running the container in detached mode
- Stopping a running container
- Using Docker Compose
- Summary
- Chapter 7: Meet Kubernetes
- Technical requirements
- In the beginning
- What is container orchestration?
- Why would you need Kubernetes?
- Self-healing
- Load-balancing and networking
- Persistent storage and volumes
- General
- Pods versus containers
- Some Kubernetes lingo
- Extending Kubernetes
- Kubernetes architecture
- Where to run Kubernetes
- Use your own hardware
- Using a hosted service.
- A simple example
- kubectl get service.
- Summary
- Chapter 8: What Is Cloud Native?
- Technical requirements
- What is cloud native?
- Cloud-native principles
- Microservices
- Containers and orchestration
- DevOps
- CI/CD
- Introducing the 12-factor app
- Code base
- Dependencies
- Config
- Backing services
- Build, release, run
- Processes
- Port binding
- Concurrency
- Disposability
- Dev/prod parity
- Logs
- Admin processes
- How to start the transformation
- Summary
- Chapter 9: Deploying Jakarta EE Applications in the Cloud
- Technical requirements
- Deploying to Azure
- Creating a container registry
- Uploading an image to the registry
- Creating a container instance
- Metrics of containers in the cloud
- Summary
- Chapter 10: Introducing MicroProfile
- Technical requirements
- A brief history of MicroProfile
- MicroProfile Config
- MicroProfile Health
- MicroProfile Fault Tolerance
- @Asynchronous
- @Retry
- @Timeout
- @Bulkhead
- @CircuitBreaker
- @Fallback
- Final remarks
- MicroProfile Metrics
- @Counted
- @Gauge
- @Metric
- @Timed
- Telemetry Tracing
- Automatic instrumentation
- Manual instrumentation
- Other specifications
- OpenAPI
- RestClient
- JSON Web Token Authentication
- Jakarta EE 10 Core Profile
- Summary
- Appendix A
- Appendix B
- Index
- Other Books You May Enjoy.
