Index

[A][B][C][D][E][F][G][H][I][J][L][M][N][O][P][Q][R][S][T][U][V][W][X][Z]

A

abstract access
access tokens, OAuth2
access_token attribute2nd
accounts, creating in Papertrail

Amazon ECS (Elastic Container Service)
  creating clusters
  manually deploying Eagle Eye services to
  starting services in
Amazon ElastiCache Service
Amazon RDS (Relational Database Service)
Amazon Web Services.
    See AWS.
annotation, Spring Cloud
antMatcher() method
Apache Avro protocol
Apache Maven2nd3rd
Apache Thrift
APIs (application program interfaces)
Application class
applications

architecture
  of build/deployment pipeline
  of configuration management
  of microservices
  of service discovery
  of Spring Cloud Stream
    binder
    channel
    sink
    source
attack surface, of microservices
auditing

authenticated users
  overview
  protecting service by

authentication service
  modifying to issue JWT
  setting up for EagleEye OAuth2
authenticationManagerBean() method
AuthenticationServerConfigurer class
authorization2nd
authorization code grants
authorizedGrantTypes() method
@Autowired annotation2nd
AWS (Amazon Web Services)
AWS_ACCESS_KEY variable
AWS_SECRET_KEY variable

B

@Bean tag
before_install attribute2nd
binders
Bitbucket

Bootstrap classes
  setting up in Spring Cloud Config
  writing
bootstrapping services, managing
branches.only attribute
brittleness, between services
$BUILD_NAME variable
build/deployment patterns, microservices

build/deployment pipeline
  architecture of
  implementing with GitHub
  implementing with Travis CI
  in action
buildFallbackLicenseList() method

bulkhead pattern
  implementing
  overview

C

CaaS (Container as a Service)2nd
cache, clearing when message is received
cache.directories attribute
cacheOrganizationObject() method
caching lookups with Redis
  configuring licensing service with Spring Data Redis dependencies
  constructing database connection to Redis server
  defining Spring Data Redis repositories
  using Redis and licensing service to store and read organization data
call() method
Callable class
capturing messaging traces
CD (Continuous Delivery)

channels
  custom, defining
  overview
checkRedisCache() method2nd
choreography, of messages
CI (Continuous Integration)
circuit breaker pattern, implementing
  customizing timeout
  timing out call to organization microservices
circuitBreaker.errorThresholdPercentage property2nd
circuitBreaker.requestVolumeThreshold property2nd
circuitBreaker.sleepWindowInMilliseconds property2nd

classes
  bootstrap
  HystrixConcurrencyStrategy, define custom
  Java callable
client applications, registering with OAuth2 service
client credential grants

client resiliency patterns
  bulkhead
  circuit breaker
  client-side load balancing
  fallback
  microservices
  overview
  with Netflix Hystrix2nd
    fallback processing
    fine-tuning
    implementing bulkhead pattern
    implementing circuit breaker
    setting up licensing servers to use
    thread context and
  with Spring Cloud
    fallback processing
    implementing bulkhead pattern
    setting up licensing servers to use
client resiliency, why it matters
client-side load balancing2nd3rd4th
ClientDetailsServiceConfigurer class
ClientHttpRequestInterceptor
clientType parameter

cloud
  defined
  microservices and
  running on desktop
    building Docker images
    building projects
    compiling projects
    downloading projects from GitHub
    launching services with Docker Compose
    required software
  service discovery in
    architecture of
    using Netflix Eureka
    using Spring
cloud caching
cloud-based applications
  building
  microservices
    build/deployment patterns
    building with Spring Boot
    client resiliency patterns
    core development patterns
    logging and tracing patterns
    overview
    routing patterns
    security patterns
  Spring
    microservices and
    overview
  Spring Boot, building microservices with
cloud-based microservices
  Spring Cloud, building with
    Netflix Hystrix libraries
    Netflix Ribbon libraries
    Netflix Zuul service gateway
    provisioning implementations
    Spring Boot
    Spring Cloud Config
    Spring Cloud Security
    Spring Cloud service discovery
    Spring Cloud Sleuth
    Spring Cloud Stream
CloudFormation

clusters
  in Amazon ECS
  Redis
coarse-grained microservices
@Column attribute
commandPoolProperties attribute2nd
commandProperties attribute2nd3rd
commands, Netflix Hystrix
communication protocols
complexity, managing

configuration
  building Spring Cloud configuration servers
    setting up Spring Cloud Config bootstrap class
    using Spring Cloud configuration server with filesystem
  controlling with Spring Cloud configuration server
    integrating Spring Cloud Config with Spring Boot client
    managing complexity
    managing configuration
  licensing services to use Spring Cloud Config
  licensing services with Spring Data Redis
  management
    architecture
    implementing
  microservices
  Netflix Zuul
  of core run-time, in Travis CI
  of microservices, managing
  of Netflix Hystrix
  protecting sensitive information
    configuring microservices to use encryption on client side
    decrypting property
    downloading Oracle JCE jars for encryption
    encrypting property
    installing Oracle JCE jars for encryption
    setting up encryption keys
  routes
    dynamic reloading
    in Netflix Zuul
  service to point to OAuth2 authentication service
  services, to point to Zipkin
  Spring Cloud
  syslog connector
  Zipkin server
configuration servers
  Spring Cloud
    building
    controlling configuration with
    refreshing properties using
    using with Git
    wiring in data source using
@Configuration tag
configure() method2nd3rd4th5th
consistency
Consul2nd
Container as a Service.
    See CaaS.
Continuous Delivery.
    See CD.
Continuous Integration.
    See CI.
Controller class
Cookie header parameter
core run-time configuration, in Travis CI
coreSize attribute

correlation IDs
  adding to HTTP response with Netflix Zuul
  building post-filter receiving
  building pre-filter generating
  Spring Cloud Sleuth and
  using in service calls
    custom RestTemplate to ensure correlation ID propogates forward
    UserContext to make HTTP headers easily accessible
    UserContextFilter to intercept incoming HTTP requests
    UserContextInteceptor to ensure correlation ID propogates forward

coupling
  loose
  tight between services
credential management
CRM (customer relationship management)2nd
cross-cutting concerns
CRUD (Create, Read, Update, Delete)2nd
CrudRepository class
custom fields, parsing out of JWT
custom spans, adding
customizing timeout on circuit breaker

D

D parameters
data source, wiring in using Spring Cloud
data transformations
database, constructing connection to Redis server
debugging
decomposing business problems
/decrypt endpoint
decrypting property
@DefaultProperties annotation
DelegatingUserContextCallable
DelegatingUserContextCallable class

dependencies
  server, settting up
  Spring Cloud Sleuth
  Spring Data Redis

deploying
  EagleEye
  microservices
    architecture of build/deployment pipeline
    build/deployment pipeline in action
    enabling service to build in Travis CI
    implementing build/deployment pipeline
    with EagleEye
  service assembly
desktops, running cloud on
  building Docker images
  building projects
  compiling projects
  downloading projects from GitHub
  launching services with Docker Compose
  required software
development patterns, microservices
DevOps (developer operations)
DevOps engineer2nd
discovery, of services2nd
  architecture of
  automated mapping of routes using
  building Spring Eureka service
  in cloud
  locating services
  manual mapping of routes using
  registering services with Spring-based Eureka server
  using Netflix Eureka
  using Spring
  using to look up service
DiscoveryClient, looking up service instances with
distributed caching
  clearing cache when message is received
  defining custom channels
  using Redis to cache lookups
    configuring licensing service with Spring Data Redis dependencies
    constructing database connection to Redis server
    defining Spring Data Redis repositories
    using Redis and licensing service to store and read organization data
distributed systems, complexity of building

distributed tracing
  with Spring Cloud Sleuth
    correlation ID and
    log aggregation and
  with Zipkin2nd
    adding custom spans
    capturing messaging traces
    configuring server
    configuring services to point to
    installing server
    integrating Spring Cloud Sleuth dependencies
    setting tracing levels
    tracing transactions
    visualizing complex transactions
DNS (Domain Name Service)

Docker
  creating images, in Travis CI
  images, building
  output, redirecting to Papertrail
Docker Compose, launching services with
Docker Hub, pushing images to
Docker Maven plugin2nd
docker ps command
DOCKER_PASSWORD variable
DOCKER_USERNAME variable
docker-compose command
docker-compose.yml
docker.sock
downloading projects from GitHub
durability
dynamic reloading, route configuration
dynamic route filters, building
  forwarding route
  implementing run() method
  skeleton of
dynamic routing

E

EagleEye
  configuring users
  creating an Amazon ECS clusters
  creating PostgreSQL database using Amazon RDS
  creating Redis cluster in Amazon ElastiCache Service
  deploying
  setting up OAuth2 authentication service
EBS (Elastic Block Storage)
ECS (Elastic Container Service)
ecs-cli command2nd
ecs-cli configure command
ecs-cli ps command
ecsInstanceRole
EDA (Event Driven Architecture)
ELB (Enterprise Load Balancer)
@EnableAuthorizationServer annotation
@EnableBinding annotation2nd
@EnableCircuitBreaker annotation2nd
@EnableDiscoveryClient annotation2nd
@EnableEurekaClient annotation
@EnableFeignClients annotation2nd
@EnableResourceServer annotation
@EnableZipkinServer annotation
@EnableZipkinStreamServer annotation
@EnableZuulProxy annotation
@EnableZuulServer annotation
/encrypt endpoint
ENCRYPT_KEY environment variable
encrypted variables

encrypting
  configuring microservices to use on client side
  downloading Oracle JCE jars
  installing Oracle JCE jars
  property
  setting up keys
encryption keys, setting up
endpoints, protecting
  authenticating users
  configuring EagleEye users
  registering client applications with OAuth2 service
  setting up EagleEye OAuth2 authentication service
@Entity annotation
environment tag
environment variables
Etcd
Eureka2nd
eureka.client.fetchRegistry attribute2nd
eureka.client.registerWithEureka attribute2nd
eureka.instance.preferIpAddress property
eureka.serviceUrl.defaultZone attribute
event processing
event-driven architecture, with Spring Cloud Stream
  architecture
  distributed caching
  downsides of messaging architecture
  using messaging to communicate state changes between services
  using synchronous request-response approach to communicate state change
  writing message consumer
  writing message producer
execution.isolation.thread.timeoutInMilliseconds property
expires_in attribute
extending JWT (JavasScript Web Tokens)

F

F5 load balancer
FaaS (Functions as a Service)
fallback pattern
fallback strategy, processing
fallbackMethod2nd
@FeignClient annotation
fields, parsing out of JWT
filesystem, using with Spring Cloud configuration servers
filterOrder() method

filters
  building
  generating correlation IDs
  in Netflix Zuul
  receiving correlation IDs
filterType() method2nd
FilterUtils class
fine-grained microservices
flexibility
forwardToSpecialRoute() method

G

geographic distribution
GET HTTP endpoint
getAbRoutingInfo() method
getCorrelationId() method
getInstances() method
getLicense() method2nd
getLicenses() method
getLicensesByOrg() method2nd3rd
getOrg() method
getOrganization() method2nd
getOrganizationId() function
getOrgDbCall
Git, using with Spring Cloud configuration servers

GitHub
  downloading projects from
  implementing build/deployment pipeline with
GITHUB_TOKEN variable2nd
Gradle
grants, in OAuth2
  authorization code grants
  client credential grants
  implicit grants
  password grants
Groovy

H

HAProxy
health, of microservices
helloRemoteServiceCall method
horizontal scalability2nd
HTTP headers
HTTP requests
HTTP response
HTTP status codes
HTTPs, using for service communication
HttpSecurity class
hystrix-javanica dependencies
@HystrixCommand annotation2nd3rd4th5th6th
HystrixConcurrencyStrategy
  configure Spring Cloud to use
  define custom classes
  define Java callable classes to inject usercontext into Hystrix commands
HystrixRuntimeException

I

IaaS (Infrastructure as a Service)2nd
@Id annotation
IETF (Internet Engineering Task Force)
ignored-services attribute

images
  building in Docker
  creating in Travis CI
  pushing to Docker Hub
immutable servers2nd
implicit grants
inbound port access
inboundOrgChanges
individual services
infection-style protocol
infrastructure
init() method
@Input annotation
installing Zipkin server

integrating
  Spring Cloud Config with Spring Boot client
    configuring licensing service to use Spring Cloud Config
    directly reading properties using @Value annotation
    refreshing properties using Spring Cloud configuration server
    setting up licensing service Spring Cloud Config server dependencies
    using Spring Cloud configuration server with Git
    wiring in data source using Spring Cloud configuration server
  Spring Cloud Sleuth dependencies with Zipkin
integration tests
intercepting incoming HTTP requests
interface design

invoking services
  with Netflix Feign client
  with Ribbon-aware Spring RestTemplate

J

J2EE stack

Java
  building microservices with
    skeleton projects
    Spring Boot controller
    writing Bootstrap class
  define callable class to inject usercontext into Hystrix commands
java.lang.ThreadLocal
JCE (Java Cryptography Extension)
JedisConnectionFactory
JPA (Java Persistence Annotations)
JSON (JavaScript Object Notation)2nd

JWT (JavasScript Web Tokens)
  consuming in microservices
  extending
  modifying authentication service to issue
  OAuth2 and
  parsing custom field out of
jwtAccessTokenConverter() method
JWTOAuth2Config class2nd
JWTTokenStoreConfig class2nd3rd

L

License class2nd
license.withComment() method
LicenseRepository class
LicenseService class
LicenseService.getLicensesByOrder() method
LicenseServiceController class
licensestatic endpoint

licensing services
  configuring to use Spring Cloud Config
  configuring with Spring Data Redis
  server dependencies
  setting up to use Netflix Hystrix
  setting up to use Spring Cloud
  using with Redis to store and read organization data
  writing message consumer in
licensing, adding Spring Cloud Sleuth to
licensingGroup
LinkedBlockingQueue
locating services
locking unneeded network ports
log aggregation, Spring Cloud Sleuth and
  adding correlation ID to HTTP response with Netflix Zuul
  configuring syslog connector
  creating Papertrail account
  implementing Papertrail
  implementing Spring Cloud Sleuth
  redirecting Docker output to Papertrail
  searching for Spring Cloud Sleuth trace IDs in Papertrail
log correlation
loggerSink() method
logging
logging and tracing patterns, microservices
logging driver, Docker
lookups, caching with Redis
  configuring licensing service with Spring Data Redis dependencies
  constructing database connection to Redis server
  defining Spring Data Redis repositories
  using Redis and licensing service to store and read organization data
loose coupling

M

main() method2nd

mapping routes
  automated using service discovery
  manual using service discovery
  manual using static URLs
Maven BOM (Bill of Materials)
maxQueueSize attribute
maxQueueSize property2nd
MDA (Message Driven Architecture)
Mercurial
message handling, semantics of
message services
MessageChannel class

messages
  choreography of
  clearing cache when received
  visibility of
  writing consumer
    in licensing service
    message services in action
  writing producer
    in organization service
    message services in action
messaging architecture, disadvantages of
messaging traces, capturing
messaging, communicating state changes between services with
  durability
  flexibility
  loose coupling
  scalability
metric collection
metrics.rollingStats.numBuckets property
metrics.rollingStats.timeInMilliseconds property
metricsRollingStats.numBuckets property
metricsRollingStats.timeInMilliseconds property
microservices
  accessing with services gateway
  build/deployment patterns
  building in Travis CI
  building with Spring Boot
  client resiliency patterns
  cloud and
  communicating health of
  configuring to use encryption on client side
  consuming JWT in
  core development patterns
  deploying
    architecture of build/deployment pipeline
    build/deployment pipeline in action
    enabling service to build in Travis CI
    implementing build/deployment pipeline
    with EagleEye
  Java, building with
    skeleton projects
    Spring Boot controller
    writing Bootstrap class
  limiting attack surface by locking down unneeded network ports
  logging and tracing patterns
  managing configuration of
  overview
  protecting single endpoint
  routing patterns
  securing
    JWT and OAuth2
    organization service using OAuth2
    with OAuth2
  security patterns
  Spring Boot, building with2nd
    designing microservice architecture
    for runtime
    skeleton projects
    Spring Boot controller
    writing Bootstrap class
  timing out call to
  when not to use
    complexity of building distributed systems
    consistency
    data transformations
    server sprawl
    types of applications
mvn spring-boot:run command

N

NAS (Network Area Storage)
nc command

Netflix Eureka
  building service using Spring Boot
  configuring Netflix Zuul to communicate with
  registering services with Spring-based server
  service discovery using
Netflix Feign

Netflix Hystrix
  and Spring Cloud
  client resiliency patterns with
    fallback processing
    fine-tuning
    implementing bulkhead pattern
    implementing circuit breaker
    setting up licensing servers to use
    thread context and
  commands
  configuration of
  thread context and
    HystrixConcurrencyStrategy
    ThreadLocal
Netflix Ribbon2nd

Netflix Zuul
  adding correlation ID to HTTP response with
  building pre-filter generating correlation IDs
  configuring routes in
    automated mapping routes via service discovery
    dynamically reload route configuration
    manual mapping of routes using static URLs
    mapping routes manually using service discovery
    service timeouts and
  configuring to communicate with Netflix Eureka
  filters
  service routing with2nd
    building dynamic route filter
    building post-filter receiving correlation IDs
    services gateways
  setting up Spring Boot project
  using Spring Cloud annotation for services
network ports, locking to limit microservices attack surface
notifications attribute

O



OAuth2
  adding jars to individual services
  grant types
    authorization code
    client credential
    implicit
    password
  JWT and
    consuming JWT in microservices
    extending JWT
    modifying authentication service to issue JWT
    parsing custom field out of JWT
  propagating access tokens
  protecting organization service with
    adding OAuth2 jars to individual services
    adding Spring Security to individual services
    configuring service to point to OAuth2 authentication service
    defining what can access services
    defining who can access services
    propagating OAuth2 access tokens
  protecting single endpoint with
    authenticating users
    configuring EagleEye users
    registering client applications with OAuth2 service
    setting up EagleEye authentication service
  refreshing tokens
  registering client applications with service
  securing microservices with
  setting up EagleEye authentication service
OAuth2Config class2nd3rd
ODS (operational data store)

Oracle JCE (Java Cryptography Extension)
  downloading jars for encryption
  installing jars for encryption
organization data
organization ID

organization services
  inflexible in adding new consumers to changes in
  protecting
  writing message producer in
OrganizationChangeHandler class
OrganizationChangeModel class
organizationId parameter
OrganizationRedisRepository interface
OrganizationRedisRepositoryImpl
organizationservice
orgChangeTopic2nd
outbound port access
output, redirecting to Papertrail
output() method

P

PaaS (Platform as a Service)2nd
packaging service assembly
Papertrail
  creating account
  implementing
  redirecting Docker output to
  searching for Spring Cloud Sleuth trace IDs in
parsing custom fields out of JWT
password grants
@PathVariable annotation2nd

patterns
  bulkhead2nd
  circuit breaker2nd3rd
  client resiliency
    bulkhead
    circuit breaker
    client-side load balancing
    fallback
    overview
    with Netflix Hystrix, 2nd
    with Spring Cloud, 2nd, 3rd
  client-side load balancing
  fallback
PCI (Payment Card Industry)2nd
peer-to-peer model
PEP (policy enforcement point)2nd
Phoenix servers2nd
physical server

pipelines, build/deployment
  architecture of
  implementing with GitHub
  implementing with Travis CI
  in action
Platform as a Service.
    See PaaS.
platform tests2nd
PLATFORM_TEST_NAME variable
port tag
post-filter, building to receive correlation IDs
Postgres database2nd3rd4th5th
PostgreSQL database, creating with Amazon RDS
POSTMAN
pre-build tools, in Travis CI
pre-filter, for generating correlation IDs
preferIpAddress attribute
private APIs, zoning services into
propagating OAuth2 access tokens
propagation

properties
  decrypting
  directly reading using @Value annotation
  encrypting
  refreshing using Spring Cloud configuration servers

propogating correlation IDs
  with RestTemplate
  withUserContextInteceptor
protected resource

protecting
  endpoints
    authenticating users
    configuring EagleEye users
    registering client applications with OAuth2 service
    setting up EagleEye OAuth2 authentication service
  services
    by authenticated users
    via specific role
protecting organization service, with OAuth2
provisioning
public APIs, zoning services into
publishOrgChange() method

Q

queueSizeRejectionThreshold attribute

R

RabbitMQ
reading properties using @Value annotation
readLicensingDataFromRedis
redirecting Docker output to Papertrail

Redis
  constructing database connection to server
  creating clusters in Amazon ElastiCache Service
  to cache lookups
    configuring licensing service with Spring Data Redis dependencies
    constructing database connection to Redis server
    defining Spring Data Redis repositories
    using Redis and licensing service to store and read organization data
  using with licensing service to store and read organization data
RedisTemplate
/refresh endpoint
refresh_token attribute2nd

refreshing
  properties using Spring Cloud configuration servers
  tokens
@RefreshScope annotation

registering
  client applications2nd
  services, with Spring-based Eureka server
registration, of services
reloading route configuration
repositories, Spring Data Redis
@RequestMapping annotation2nd
resource owner
ResponseBody class
ResponseFilter
REST endpoint
REST philosophy
REST-oriented (Representational State Transfer)
@RestController annotation

RestTemplate
  Ribbon-aware
  to ensure correlation ID propagates forward
restTemplate.exchange() method
$RESULTS variable
retrieveOrgInfo() method
Ribbon project
route filters, building dynamic
  forwarding route
  implementing run() method
  skeleton of

routes
  configuring in Netflix Zuul
    automated mapping routes via service discovery
    dynamically reload route configuration
    manual mapping of routes using static URLs
    mapping routes manually using service discovery
    service timeouts and
  forwarding
  mapping
    automated using service discovery
    manual using service discovery
    manual using static URLs
routing patterns, microservices
run-time configuration, CI
run() method2nd
runtime, building microservices for
  communicating microservice health
  service assembly
  service bootstrapping
  service discovery
  service registration

S

SaaS (Software as a Service)
Sampler class
scalability
Scope attribute
scopes() method
searching for Spring Cloud Sleuth trace IDs
searchLocations attribute
secret() method
Secure Sockets Layer.
    See SSL.
securing microservices2nd
  accessing microservices with services gateway
  JWT and OAuth2
  limiting attack surface of microservices
  protecting organization service using OAuth2
  protecting single endpoint with OAuth2
  protecting single endpoint with Spring
  using HTTPs for service communication
  using SSL for service communication
  with OAuth2
  zoning services into public API and private API
security patterns, microservices
security.oauth2.resource.userInfoUri property
semantics, of message handling
SEMAPHORE-based isolation
send() method
sensitive information, protecting
  configuring microservices to use encryption on client side
  decrypting property
  downloading Oracle JCE jars for encryption
  encrypting property
  installing Oracle JCE jars for encryption
  setting up encryption keys

server
  dependencies
  Zipkin
    configuring
    installing
server sprawl
server.port attribute

service assembly
  deploying
  packaging
service bootstrapping, managing configuration of microservices
service calls, using correlation IDs in
  custom RestTemplate to ensure correlation ID propogates forward
  UserContext to make HTTP headers easily accessible
  UserContextFilter to intercept incoming HTTP requests
  UserContextInteceptor to ensure correlation ID propogates forward
service discovery
  architecture of
  automated mapping of routes using
  building Spring Eureka service
  in cloud
    architecture of
    using Netflix Eureka
    using Spring
  locating services
  manual mapping of routes using
  registering services with Spring-based Eureka server
  using Netflix Eureka
  using Spring
  using to look up service
    invoking services with Netflix Feign client
    invoking services with Ribbon-aware Spring RestTemplate
    looking up service instances with Spring DiscoveryClient
service granularity2nd
service interfaces
service monitoring
service registration

service routing
  with Netflix Zuul2nd
    building dynamic route filter
    building post-filter receiving correlation IDs
    building pre-filter generating correlation IDs
    configuring routes
    configuring to communicate with Netflix Eureka
    filters
    services gateways
    setting up Spring Boot project
    using Spring Cloud annotation for services
  with Spring Cloud2nd
    building dynamic route filter
    building post-filter receiving correlation IDs
    services gateways
    using annotation for Netflix Zuul services
service startups
service timeouts2nd
ServiceInstance class
servicename.ribbon.ReadTimeout property

services
  brittleness between
  communicating state changes between with messaging
    durability
    flexibility
    loose coupling
    scalability
  configuring to point to Zipkin
  defining what has access to
    protecting service by authenticated users
    protecting service via specific role
  defining who has access to2nd
    protecting service by authenticated users
    protecting service via specific role
  invoking
    with Netflix Feign client
    with Ribbon-aware Spring RestTemplate
  launching with Docker Compose
  locating
  looking up using service discovery
    invoking services with Netflix Feign client
    invoking services with Ribbon-aware Spring RestTemplate
    looking up service instances with Spring DiscoveryClient
  protecting
    by authenticated users
    via specific role
  registering with Spring-based Eureka server
  starting in Amazon ECS
  tight coupling between
  zoning into public API and private API

services gateways
  accessing microservices with
  overview
setContext() method
setCorrelationId() method
shouldFilter() method2nd
Simple Queueing Service.
    See SQS.
SimpleHostRoutingFilter class
Single Sign On.
    See SSO.
sinks
skeleton projects
SOAP (Simple Object Access Protocol)
Software as a Service.
    See SaaS.
software engineer
Source class
source control code, tagging in Travis CI
sources
span ID
spans, custom
SpecialRoutes
SpecialRoutesFilter2nd3rd
SPIA (Single Page Internet Applications)

Spring
  microservices and
  overview
  protecting single endpoint with
    authenticating users
    configuring EagleEye users
    registering client applications with OAuth2 service
    setting up EagleEye OAuth2 authentication service
  registering services with Netflix Eureka server
  service discovery using
Spring Actuator module

Spring Boot
  building microservices with2nd3rd
    designing architecture
    for runtime
    skeleton projects
    Spring Boot controller
    writing Bootstrap class
  building Netflix Eureka service with
  client
  controller
  setting up Netflix Zuul project
  when not to use microservices
    complexity of building distributed systems
    consistency
    data transformations
    server sprawl
    types of applications

Spring Cloud
  and Netflix Hystrix
  building microservices with
    Netflix Hystrix libraries
    Netflix Ribbon libraries
    Netflix Zuul service gateway
    provisioning implementations
    Spring Boot
    Spring Cloud Config
    Spring Cloud Security
    Spring Cloud service discovery
    Spring Cloud Sleuth
    Spring Cloud Stream
  client resiliency patterns with
    fallback processing
    implementing bulkhead pattern
    setting up licensing servers to use
  configuration servers
    building
    controlling configuration with
    refreshing properties using
    using with filesystem
    using with Git
    wiring in data source using
  configuring to use custom HystrixConcurrencyStrategy
  service discovery
  service routing with2nd
    building dynamic route filter
    building post-filter receiving correlation IDs
    services gateways
  using annotation for Netflix Zuul services
Spring Cloud Config
  configuring licensing service to use
  integrating with Spring Boot client
    directly reading properties using @Value annotation
    refreshing properties using Spring Cloud configuration server
    using Spring Cloud configuration server with Git
    wiring in data source using Spring Cloud configuration server
  setting up bootstrap classes
  setting up licensing service server dependencies
Spring Cloud Security

Spring Cloud Sleuth
  adding to licensing
  adding to organization
  anatomy of trace
  correlation ID and
  dependencies
  distributed tracing with
  implementing
  log aggregation and
    adding correlation ID to HTTP response with Zuul
    configuring syslog connector
    creating Papertrail account
    implementing Papertrail
    implementing Spring Cloud Sleuth
    redirecting Docker output to Papertrail
  trace IDs

Spring Cloud Stream
  architecture of
    binder
    channel
    sink
    source
  event-driven architecture with
    distributed caching
    downsides of messaging architecture
    using messaging to communicate state changes between services
    using synchronous request-response approach to communicate state change
    writing message consumer
    writing message producer

Spring Data Redis
  defining repositories
  dependencies
Spring Security, adding to individual services
spring-cloud-security dependency
spring-cloud-sleuth-zipkin dependency
spring-cloud-starter-eureka library
spring-cloud-starter-sleuth dependency
spring-security-jwt dependency
spring-security-oauth2 dependency
spring.application.name property2nd
spring.cloud.config.uri property
spring.cloud.stream.bindings property
spring.cloud.stream.bindings.input.group property
spring.datasource.password
spring.profiles.active property
spring.stream.bindings.kafka property
spring.stream.bindings.output property
spring.zipkin.baseUrl property
@SpringBootApplication annotation
SQS (Simple Queueing Service)
SSL (Secure Sockets Layer)2nd
SSO (Single Sign On)

state changes
  communicating between services with messaging
    durability
    flexibility
    loose coupling
    scalability
  communicating with synchronous request-response approach
    brittleness between services
    inflexible in adding new consumers to changes in the organization service
    tight coupling between services
static routing
static URLs, manual mapping of routes using
@StreamListener annotation2nd
SubscribableChannel class
Subversion
sudo attribute
synchronous request-response approach
  brittleness between services
  inflexible in adding new consumers to changes in the organization service
  tight coupling between services
SynchronousQueue
syslog, configuring connector

T

@Table annotation
tag_name value
tagging source control code
technology-neutral protocol
ThoughtMechanix
thread context, Netflix Hystrix and
  HystrixConcurrencyStrategy
  ThreadLocal
THREAD isolation
ThreadLocal, Netflix Hystrix and
ThreadLocalAwareStrategy.java
ThreadLocalConfiguration
threadPoolKey property
threadPoolProperties attribute2nd
Thrift
timeout, customizing on circuit breaker
tmx-correlation-id header2nd
token_type attribute
tokens, refreshing
tokenServices() method
tools, installation in Travis CI
trace ID
traceability
Tracer class2nd

tracing
  setting levels
  transactions with Zipkin
TrackingFilter class2nd3rd

transactions
  complex, visualizing
  tracing with Zipkin
Travis CI
  enabling service to build in
    building microservices
    core build run-time configuration
    creating Docker images
    executing build
    invoking platform tests
    pre-build tool installations
    pushing images to Docker Hub
    starting services in Amazon ECS
    tagging source control code
  implementing build/deployment pipeline with
travis.yml file
Twelve-Factor Application manifesto

U

UDDI (Universal Description, Discovery, and Integration) repository
unit tests
URLs (Uniform Resource Locator)
UserContext2nd
usercontext
UserContext.AUTH_TOKEN
UserContextFilter2nd
UserContextFilter class
UserContextHolder class
UserContextInteceptor
UserContextInterceptor class2nd3rd
userDetailsServiceBean() method

users
  authenticated, protecting service by
  authenticating
  of EagleEye, configuring
useSpecialRoute() method
utils package

V

@Value annotation
versioning scheme
virtual containers
virtual machine images
visibility, of messages
visualizing complex transactions
VPC (Virtual Private Cloud)

W

WebSecurityConfigurerAdapter
WebSecurityConfigurerAdapter class
WebSphere
wiring data source
withClient() method
wrapCallable() method
writing Bootstrap classes

X

XML (Extensible Markup Language)

Z



Zipkin
  configuring services to point to
  distributed tracing with2nd
    adding custom spans
    capturing messaging traces
    configuring server
    configuring services to point to
    installing server
    integrating Spring Cloud Sleuth dependencies
    setting tracing levels
    tracing transactions
    visualizing complex transactions
  server
    configuring
    installing
  tracing transactions with
ZooKeeper
ZuulFilter class2nd
ZuulRequestHeaders
zuulservice