Name: Hands-On Microservices with Kotlin
Author: Juan Antonio Medina Iglesias
ISBN: 9781788473491

微信读书书城Hands-On Microservices with Kotlin

首页我的书架登录

翻译完成

切换

Hands-On Microservices with Kotlin

Juan Antonio Medina Iglesias

扉页
coverpage
+书签
Title Page
Dedication
Packt Upsell
Why subscribe?
PacktPub.com
Contributors
About the author
About the reviewers
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
Understanding Microservices
What is a microservice?
Understanding SoA
Differentiating microservices from SoA
From the monolith to microservices
Microservices principles
Defining design principles
Modelled around business capabilities
Loosely couple
Single responsibility
Hiding implementation
Isolation
Independently deployable
Build for failure
Upstream
Downstream
Logging
Monitoring
Alerting
Recovery
Fallbacks
Scalability
Automation
Domain-Driven Design
What is Domain-Driven Design
Ubiquitous language
Bounded context
Context mapping
Using DDD in microservices
Reactive microservices
Reactive programming
Reactive Manifesto
Responsive
Resilient
Elastic
Message-driven
Back pressure
Reactive frameworks
Reactive Extensions
Project Reactor
Java reactive streams
Akka
Reactive microservices
Cloud Native microservices
Cloud computing
Containers
Deployment models
Private cloud
Public cloud
Hybrid cloud
Service models
Infrastructure as a Service
Platform as a Service
Software as a Service
Cloud Native microservices
Summary
Getting Started with Spring Boot 2.0
Creating a Spring Boot application
Setting up
Installing JDK 8
UNIX/Mac OS X
Windows
Testing the installation
Installing Maven 3.5
Unix /MacOS X
Windows
Testing the installation
Installing IntelliJ IDEA CE 2017.2
Using Spring Initializr
Understanding basic usage
Reviewing the generated project files
Maven Files
Source files
Resource files
Gitignore
Understanding advanced usage
Using Maven
Life cycle phases
Introduction to Maven goals
Understanding the POM file
Project definition
Maven parent
Project properties
Dependencies
Build
Repositories
Using IntelliJ IDEA
Opening our Maven project
Executing life cycle phases and goals
Modifying our microservice
Debugging
Tips and Tricks
Spring Boot application structure
Creating an application object
Defining Spring application context
Understanding the component scan
Using components
Autowiring
Packaging and running a Spring Boot application
Packaging
Making JARs not WARs
Running Spring Boot applications
Creating executable JARs
Configuring our application
Setting configuration values
Using properties
Using Yaml
Using command-line arguments
Understanding Spring Expression Language
Using profiles
Defining profile values
Executing with profiles
Creating conditional beans
Creating beans explicitly
Defining an additional bean
Defining beans with conditionals
Running different configurations
Summary
Creating RESTful Services
Understanding RestController
What is a controller
Creating a RestController
Understanding our controller
Path and request parameters
Creating a map of customers
Getting path variables
Understanding path variables
Defining request parameters
Understanding request parameters
HTTP verbs and statuses
Standard HTTP verbs and statuses
Single resources
Collections
Generic errors
Handling HTTP verbs
Handling HTTP POST
Handling HTTP DELETE
Handling HTTP PUT
Using verb and mapping annotations
Implementing a service layer
Creating a service interface
Creating an implementation
Binding the right bean
Using the service
Handling HTTP statuses
Using ResponseEntity
Answering a GET request
Answering a POST request
Answering a DELETE request
Answering an UPDATE request
Empty responses
Working with JSON
Understanding serialization
Using simple objects
Working with complex objects
Adding telephones to our customers
Handling null values
Understanding deserialization
From a request into an object
Deserializing complex objects
Validating objects
Handling errors
Using controller advice
Creating business exceptions
Avoiding the controller advice
Summary
Creating Reactive Microservices
Understanding Spring WebFlux
Creating a Spring WebFlux application
Using Netty
Serving static context
Adding a RestController
Creating a customer service
Blocking is not reactive
Creating reactive services
Understanding subscribers and publishers
Publishing a single object
Using Mono in a service
Publishing multiple objects
Using Flux in a service
Receiving objects reactively
Using functional web programming
Using RouterFunction
Creating handlers
Using reactive services
Handling multiple routes
Using query parameters
Processing a JSON body
Handling reactive errors
Capturing errors on Handlers
Publishing errors
Summary
Reactive Spring Data
NoSQL databases
What is a SQL database?
What is a NoSQL database?
Installing MongoDB
Starting our database server
Connecting with the Mongo client
Creating a database
Using commands
Using Spring Data
Setting up the project
Configuring our connection
Sending commands to MongoDB
Reactive repositories
Creating a repository
Using the repository
Completing our initialization
Using ReactiveMongoTemplate
From CRUD to REST
Bringing back our service
Mapping GET to READ
Mapping POST to CREATE
Mapping DELETE
Finding Customers
Summary
Creating Cloud-Native Microservices
Understanding Spring Cloud
What is a Cloud-Native application?
Spring Cloud architecture
Configuration server
Service discovery
Load Balancer
Gateway
Circuit breaker
Spring Cloud Netflix
Creating a Spring Cloud microservice
Configuration Server
Creating a Configuration Server
Getting configurations
Ciphering data
Using application profiles
Service discovery
Creating a Service Discovery Server
Connecting to the Discovery Server
Using Spring Boot actuator
Gateway
Creating a Gateway
Defining routes
Summary
Creating Dockers
Starting with Docker
Understanding containers
Virtual machines
Containers
Docker
Installing Docker
Starting with Docker
Pulling images
Managing images
Building Dockers with microservices
Creating an example microservice
Creating a Dockerfile
Dockerize our microservice
Running the microservice
Publishing Dockers
Understanding repositories
Creating an account on Docker Hub
Publishing a Docker
Integrating Docker with Maven
Summary
Scaling Microservices
A scalable architecture
Scaling directions
Vertical scaling
Horizontal scaling
Design for scaling
Independently scaling
Scaling down
Creating a Cloud
Creating a swarm
Adding a service
Getting logs from a service
Deleting a service
Publishing a microservice as a service
Creating a registry
Creating a microservice
Creating our Docker
Creating the service
Controlling services
Scaling instances
Getting logs from a service
Controlling the service
Summary
Testing Spring Microservices
Understanding SpringBootTest
Creating a simple microservice
Understanding SpringBootTest
Testing beans
Using MockMvc
Mocking beans
Why we mock
Setting up a mock
Returning mocked values
Verifying Mock invocation
Fluent tests
Adding Kluent
Testing our services expressively
Testing our controller expressively
Summary
Monitoring Microservices
Understanding monitoring
What is monitoring?
Alerting
Recovering
Building a failing microservice
SpringBoot Actuator
Enabling SpringBoot Actuator
Understanding Actuator s endpoints
Health endpoint
Metrics endpoint
Trace endpoint
Defining health indicators
Protecting Actuator endpoints
Java Managing Extensions
Understanding JMX
Using JMX
Create management beans
Summary
Deploying Microservices
Setting things up
Creating a GitHub account
Installing Git
Create an OpenShift account
Downloading the OpenShift client
Building our application
Creating an example microservice
Adding tests
Uploading to GitHub
Publishing to OpenShift
Creating an application
Managing our application
Updating the application
Summary
Best Practices
Using Kotlin idioms
Inferred types
Expressions
Default parameters
Lambda
Managing the Spring context
Constructor injection
Explicit context configuration
Decouple services
Layering the application
Understanding our classes
Domains
Splitting
Testing effectively
Understanding type of tests
Unit tests
Integration tests
E2E tests
Other tests
Testing pyramid
Test Driven Development
Behavior-Driven Development
Handling CI and CD
Continuous Integration
Continuous Delivery
Pipeline
Dashboard
Summary
Other Books You May Enjoy
Leave a review - let other readers know what you think

简介

版权

Hands-On Microservices with Kotlin