Index
A
- abracad
- reference link / Using Avro for data transfer
- ACID properties
- reference link / Data management, Transactions
- Aero
- reference link / Using Omniconf for configuration
- AES 128-bit algorithm / Creating a secret key for JSON Web Encryption
- aggregation queries
- reference link / Getting status with aggregation queries
- status, obtaining / Getting status with aggregation queries
- Alerting Component / Application components
- Alert service
- creating / Creating a microservice for alerts
- routes, adding / Adding routes
- email interceptor, creating with Postal / Creating an email interceptor using Postal
- integrating, with Apache Kafka / Integrating the Alert Service with Kafka
- Amazon
- reference link / Monolithic applications to microservices
- Analytical Engine
- reference link / Dawn of application architecture
- Apache Kafka
- about / Introduction to Apache Kafka, Monitoring microservices
- design principles / Design principles
- obtaining / Getting Kafka
- URL, for downloading / Getting Kafka
- reference link / Getting Kafka
- using, as messaging system / Using Kafka as a messaging system
- using, as event store / Using Kafka as an event store
- using, for Helping Hands application / Using Kafka for Helping Hands
- APIs / Using Kafka for Helping Hands
- Producer API / Using Kafka for Helping Hands
- Consumer API / Using Kafka for Helping Hands
- Streams API / Using Kafka for Helping Hands
- Connect API / Using Kafka for Helping Hands
- AdminClient API / Using Kafka for Helping Hands
- APIs, using / Using Kafka APIs
- initializing, with mount / Initializing Kafka with Mount
- Alert Service, integrating with / Integrating the Alert Service with Kafka
- Avro, used for data transfer / Using Avro for data transfer
- URL / Monitoring microservices
- Apache Kafka configuration
- reference link / Using Kafka as an event store
- Apache Zookeeper
- URL / Service registry, Getting Kafka
- application architecture / Dawn of application architecture
- application components
- Registration Component / Application components
- Service Component / Application components
- Order Component / Application components
- Geo Location Component / Application components
- Alerting Component / Application components
- application states
- managing, with mount / Managing application states with mount
- Atom
- URL / Clojure IDE
- reference link / Using Kafka APIs
- authentication
- about / Enabling authentication and authorization
- enabling / Enabling authentication and authorization
- tokens / Introducing Tokens and JWT
- JWT / Introducing Tokens and JWT
- Auth service, creating for Helping Hands app / Creating an Auth service for Helping Hands
- authorization
- about / Enabling authentication and authorization
- enabling / Enabling authentication and authorization
- tokens / Introducing Tokens and JWT
- JWT / Introducing Tokens and JWT
- Auth service, creating for Helping Hands app / Creating an Auth service for Helping Hands
- Auth service
- creating, for Helping Hands app / Creating an Auth service for Helping Hands
- Nimbus JOSE JWT library, using for tokens / Using a Nimbus JOSE JWT library for Tokens
- secret key for JSON Web Encryption, creating / Creating a secret key for JSON Web Encryption
- tokens, creating / Creating Tokens
- roles, enabling for authorization / Enabling users and roles for authorization
- users, enabling for authorization / Enabling users and roles for authorization
- APIs, creating with Pedestal / Creating Auth APIs using Pedestal
- automated continuous deployment
- about / Automated continuous deployment
- CI/CD / CI/CD
- scaling / Scaling
- ava REST Client
- reference link / Creating query interceptors
- Avro
- using, for data transfer / Using Avro for data transfer
- URL / Using Avro for data transfer
- references / Using Avro for data transfer
B
- BlueGreenDeployment
- reference link / CI/CD
- body-params
- reference link / Accessing request parameters
- Bool Query
- reference link / Creating query interceptors
- Boot
- bounded context
- reference link / Microservices
- about / Bounded context
- identifying / Identifying bounded contexts
- organizing around / Organizing around bounded contexts
- bounding box query
- reference link / Using geo queries
- Buddy
- reference link / Creating Auth APIs using Pedestal
- Buddy Sign
- reference link / Creating Auth APIs using Pedestal
- builder pattern
- reference link / Declaring routers
- business logic layer / Monolithic architecture
C
- C++
- reference link / Monolithic applications to microservices
- cgroups
- reference link / Introducing Containers and Docker
- chain-of-responsibility pattern
- reference link / The interceptor chain
- chain providers
- using / Using chain providers
- Cheshire
- reference link / Accessing request parameters
- CIDER
- reference link / Clojure IDE, Using interceptors and handlers
- client-side discovery pattern / Service discovery patterns
- Client Library
- reference link / Development model
- clj-http
- reference link / Creating interceptors
- clj-http GET
- reference link / Creating interceptors
- Clojars
- URL / Leiningen
- Clojure
- URL / User stories, Clojure and REPL
- about / Clojure and REPL
- history / History of Clojure
- Clojure build tools
- about / Clojure build tools
- Leiningen / Leiningen
- Boot / Boot
- Clojure clj tool
- reference link / REPL
- ClojureCLR
- reference link / Clojure and REPL
- Clojure function
- reference link / Interceptors
- Clojure IDE / Clojure IDE
- Clojure Map
- reference link / Interceptors
- Clojure project
- about / Clojure project
- configuring / Configuring a project
- executing / Running a project
- tests, executing / Running tests
- reports, generating / Generating reports
- artifacts, generating / Generating artifacts
- Clojure REPL
- reference link / REPL
- Cloverage
- reference link / Configuring a project
- Codox
- reference link / Configuring a project
- Collectd
- URL / Using ELK Stack for monitoring
- about / Using ELK Stack with Collectd
- ELK stack, using / Using ELK Stack with Collectd
- Collectd Codec
- reference link / Using ELK Stack with Collectd
- Command Query Responsibility Segregation (CQRS) pattern
- references / Using the CQRS pattern
- about / Using the CQRS pattern
- using / Using the CQRS pattern
- command side / Using the CQRS pattern
- Common Language Runtime (CLR) / Clojure and REPL
- Common Lisp
- reference link / History of Clojure
- communications protocols
- reference link / Using WebSockets
- components
- about / Components
- reference link / Components
- hexagonal architecture / Hexagonal architecture
- references / Managing application states with mount
- Config
- reference link / Using Omniconf for configuration
- configuration parameters
- defining / Defining configuration parameters
- using / Using configuration parameters
- consul
- URL / Service registry
- Consumer Group / Design principles, Using Kafka as a messaging system
- containers
- reference link / Release cycle and the deployment process
- context
- designing / Designing the interceptor chain and context
- Context Map
- about / Interceptors
- importance / Importance of a Context Map
- continuous delivery (CD) / Automated continuous deployment
- continuous integration (CI) / Domain-driven design
- contracts
- about / Messaging and contracts
- service contracts / Service contracts
- Coordinated Universal Time
- reference link / Logging and monitoring guidelines
- core.async
- reference link / The interceptor chain
- core business logic / Hexagonal architecture
- Counterclockwise
- URL / Clojure IDE
- C programming
- reference link / Using ELK Stack with Collectd
- Cross Cluster Search
- about / Setting up Elasticsearch
- reference link / Setting up Elasticsearch
D
- database adapter / Hexagonal architecture
- database port / Hexagonal architecture
- Datalog
- reference link / Using Datalog to query
- Datalog to query
- using / Using Datalog to query
- data management
- about / Data management, Data management
- direct lookup / Direct lookup
- asynchronous events / Asynchronous events
- data, combining / Combining data
- transactions / Transactions
- data model / Data model, Interceptor for the data model
- data structure
- reference link / The interceptor chain
- data transfer
- Avro, using for / Using Avro for data transfer
- Datomic
- URL / Isolating services by persistence
- architecture / Datomic architecture
- about / Datomic architecture
- references / Datomic architecture, Datomic versus traditional database, Schema
- versus traditional database / Datomic versus traditional database
- development model / Development model
- data model / Data model
- schema / Schema
- using / Using Datomic
- starting with / Getting started with Datomic
- database, connecting to / Connecting to a database
- data, transacting / Transacting data
- Datalog to query, using / Using Datalog to query
- immutability / Achieving immutability
- database, deleting / Deleting a database
- reference link / Deleting a database
- Datomic query grammar
- reference link / Using Datalog to query
- Datomic schema
- defining / Defining the Datomic schema
- Datoms / Data model
- defrecord
- reference link / Creating a persistence adapter
- denormalization
- reference link / Isolating services by business logic
- developers (dev) / Release cycle and the deployment process
- direct messaging / Direct messaging
- Discover module
- reference link / Setting up Kibana
- about / Setting up Kibana
- distance query
- reference link / Using geo queries
- Docker
- reference link / Release cycle and the deployment process, Introducing Containers and Docker, Setting up Docker
- about / Introducing Containers and Docker
- setting up / Setting up Docker
- references / Setting up Docker
- image, creating for Helping Hands apps / Creating a Docker image for Helping Hands
- docker build
- reference link / Creating a Docker image for Helping Hands
- domain-driven design
- about / Domain-driven design
- bounded context / Bounded context
- bounded context, identifying / Identifying bounded contexts
- bounded context, organizing around / Organizing around bounded contexts
E
- Elasticsearch
- URL / Limitations, Isolating services by persistence
- about / Defining the Elasticsearch index
- reference link / Using ELK Stack for monitoring, Using ELK Stack with Collectd
- URL, for downloading / Setting up Elasticsearch
- setting up / Setting up Elasticsearch
- references / Setting up Elasticsearch
- Elasticsearch 6.1.1
- URL, for downloading / Setting up Elasticsearch
- Elasticsearch index
- defining / Defining the Elasticsearch index
- Elasticsearch index mapping
- reference link / Using ELK Stack with Collectd
- ELK Stack
- used, for monitoring / Using ELK Stack for monitoring
- reference link / Using ELK Stack for monitoring
- email interceptor
- creating, with Postal / Creating an email interceptor using Postal
- Environ
- reference link / Using Omniconf for configuration
- Epochal time model
- reference link / History of Clojure
- error-dispatch
- reference link / Handling errors and exceptions
- errors
- handling / Handling errors and exceptions
- ESB
- reference link / Data management
- etcd
- URL / Service registry
- reference link / Introducing Kubernetes
- event-driven patterns
- implementing / Implementing event-driven patterns
- event sourcing / Event sourcing
- CQRS pattern, using / Using the CQRS pattern
- EventSource API
- reference link / Using server-sent events (SSE)
- event sourcing / Event sourcing
- event store
- Apache Kafka, using as / Using Kafka as an event store
- eventual consistency
- reference link / Transactions
- example-boot
- reference link / Integrating with Helping Hands
- example-lein
- reference link / Integrating with Helping Hands
- exceptions
- handling / Handling errors and exceptions
- expand-routes
- reference link / Creating routes
F
- filter context
- reference link / Creating query interceptors
- Fireplace
- reference link / Clojure IDE
- First steps
- about / Using ELK Stack with Collectd
- reference link / Using ELK Stack with Collectd
- Fluorine
- reference link / Using Omniconf for configuration
- full-duplex
- reference link / Using WebSockets
G
- generic interceptors
- defining / Defining generic interceptors
- for Auth / Interceptor for Auth
- for data model / Interceptor for the data model
- for events / Interceptor for events
- geo-point
- reference link / Getting status with aggregation queries
- geo-shape
- reference link / Getting status with aggregation queries
- Geo Location Component / Application components
- geo queries
- reference link / Using geo queries
- using / Using geo queries
- Get Datomic
- reference link / Using Datomic
- go blocks
- reference link / The interceptor chain
- GPUs
- reference link / Extensibility
- graph database
- reference link / Data management
H
- handlers
- using / Using interceptors and handlers
- Helping Hands application
- designing / Design
- users / Users and entities
- entities / Users and entities
- user stories / User stories
- domain model / Domain model
- deploying / Deployment
- limitations / Limitations
- microservices / Moving to microservices
- Apache Kafka, using for / Using Kafka for Helping Hands
- Auth service, creating for / Creating an Auth service for Helping Hands
- Helping Hands application, workflows
- about / Workflows for Helping Hands
- service provider workflow / Service provider workflow
- service workflow / Service workflow
- service workflows / Service workflow
- service consumer workflow / Service consumer workflow
- order workflow / Order workflow
- Helping Hands services
- interceptors / Designing the interceptor chain and context
- hexagonal architecture
- about / Hexagonal architecture, Implementing Hexagonal Architecture
- reference link / Hexagonal architecture, Implementing Hexagonal Architecture
- implementing / Implementing Hexagonal Architecture
- interceptor chain, designing / Designing the interceptor chain and context
- context, designing / Designing the interceptor chain and context
- Pedestal project, creating / Creating a Pedestal project
- generic interceptors, defining / Defining generic interceptors
- horizontal scaling
- reference link / Introducing Kubernetes
- HTTP
- reference link / Service contracts
- HTTP methods
- reference link / RESTful APIs
- HTTP status codes
- reference link / Status codes
I
- Immutant
- URL / Using chain providers
- input plugin, Kafka
- reference link / Logging and monitoring guidelines
- integrated development environment (IDE) / Clojure IDE
- interceptor
- about / Interceptors
- using / Using interceptors and handlers
- creating / Creating interceptors, Creating interceptors
- creating, for SSE / Creating interceptors for SSE
- interceptor chain
- about / The interceptor chain
- designing / Designing the interceptor chain and context
- IntoInterceptor protocol
- reference link / Using interceptors and handlers
- IoT
- reference link / Datomic versus traditional database
J
- JAR file, Clojure
- reference link / REPL
- Java APIs
- reference link / Creating query interceptors
- Java Management Extensions (JMX)
- reference link / Publishing operational metrics
- Java virtual machine (JVM) / Clojure and REPL
- JConsole
- reference link / Publishing operational metrics
- Jetty
- WebSocket, using / Using WebSocket with Pedestal and Jetty
- Jetty web server
- URL / Using chain providers
- JSON Web Encryption (JWE) / Introducing Tokens and JWT
- JSON Web Key
- reference link / Creating a secret key for JSON Web Encryption
- JSON Web Signature (JWS) / Introducing Tokens and JWT
- JSON Web Token (JWT) / Introducing Tokens and JWT
- JWE RFC-7516
- reference link / Introducing Tokens and JWT
- JWK RFC-7517
- reference link / Creating a secret key for JSON Web Encryption
- JWS RFC-7515
- reference link / Introducing Tokens and JWT
- JWT RFC-7519
- reference link / Introducing Tokens and JWT
K
- Kafka consumers / Design principles
- Kafka Manager
- reference link / Getting Kafka
- Kafka producers / Design principles
- Kafka wrappers
- reference link / Using Kafka APIs
- kernel namespaces
- reference link / Introducing Containers and Docker
- Keyword Analyzer
- reference link / Creating query interceptors
- Kibana
- URL, for downloading / Setting up Kibana
- Kibana 6.1.1
- URL, for downloading / Setting up Kibana
- kube-apiserver
- reference link / Introducing Kubernetes
- kube-controller-manager
- reference link / Introducing Kubernetes
- kube-proxy
- reference link / Introducing Kubernetes
- kubelet
- reference link / Introducing Kubernetes
- Kubernetes
- reference link / Release cycle and the deployment process
- URL / Service registry
- about / Introducing Kubernetes
- references / Introducing Kubernetes
- starting with / Getting started with Kubernetes
- Kubernetes master / Introducing Kubernetes
- Kubernetes node / Introducing Kubernetes
L
- Lambda calculus / History of Clojure
- Last-Event-ID
- reference link / Creating interceptors for SSE
- Leiningen
- URL / User stories, REPL
- about / Leiningen
- reference link / Leiningen
- Lein script
- reference link / Leiningen
- Light Table
- URL / Clojure IDE
- Linux Containers (LXC)
- reference link / Deploying microservices at scale
- about / Introducing Containers and Docker
- Linux Kernel
- reference link / Introducing Containers and Docker
- Lisp
- reference link / Clojure and REPL
- Lisp programming language / History of Clojure
- Load Balancing / Introducing Kubernetes
- Loading Sample Data
- reference link / Setting up Kibana
- about / Setting up Kibana
- log4j
- references / Logging and monitoring guidelines
- Logback
- URL / Logging
- logging / Logging
- Logstash
- reference link / Using ELK Stack for monitoring, Setting up Logstash
- setting up / Setting up Logstash
- URL, for downloading / Setting up Logstash
- Logstash 6.1.1
- URL, for downloading / Setting up Logstash
- Lookup service
- creating / Creating a microservice for Lookup
- API / Creating a microservice for Lookup
- Elasticsearch index, defining / Defining the Elasticsearch index
- query interceptors, creating / Creating query interceptors
- geo queries, using / Using geo queries
- aggregation queries, status obtaining / Getting status with aggregation queries
M
- MapD
- reference link / Extensibility
- maps
- reference link / Creating routes
- MBean
- reference link / Publishing operational metrics
- media type
- reference link / RESTful APIs, Using interceptors and handlers
- Memcached
- reference link / Datomic versus traditional database
- Mesos
- URL / CI/CD
- message-oriented middleware (MOM)
- reference link / Data management, Messaging and contracts
- about / Messaging and contracts
- Message Authentication Codes (MACs) / Introducing Tokens and JWT
- message broker
- reference link / Observer model, Design principles
- messaging
- about / Messaging and contracts
- direct messaging / Direct messaging
- observer model / Observer model
- messaging system
- Apache Kafka, using as / Using Kafka as a messaging system
- MetaWeather
- reference link / Using RESTful APIs via cURL
- MetricRegistry
- reference link / Publishing operational metrics
- microservice for Order
- creating / Creating a microservice for Order
- routes, adding / Adding routes
- Datomic schema, defining / Defining Datomic schema
- persistence adapter, creating / Creating a persistence adapter
- interceptors, creating / Creating interceptors
- routes, testing / Testing routes
- microservices
- about / Microservices
- data management / Data management
- monolithic applications to / Monolithic applications to microservices
- candidates, identifying for / Identifying candidates for microservices
- deployment process / Release cycle and the deployment process
- release cycle / Release cycle and the deployment process
- moving / Moving to microservices
- isolating, by persistence / Isolating services by persistence
- isolating, by business logic / Isolating services by business logic
- messaging / Messaging and events
- events / Messaging and events
- extensibility / Extensibility
- monitoring / Monitoring microservices
- ELK Stack, used for monitoring / Using ELK Stack for monitoring
- Elasticsearch, setting up / Setting up Elasticsearch
- Kibana, setting up / Setting up Kibana
- Logstash, setting up / Setting up Logstash
- ELK stack, using with Collectd / Using ELK Stack with Collectd
- monitoring guidelines / Logging and monitoring guidelines
- logging guidelines / Logging and monitoring guidelines
- microservices, at scale
- deploying / Deploying microservices at scale
- LCX / Introducing Containers and Docker
- Docker / Introducing Containers and Docker
- Kubernetes / Introducing Kubernetes
- Kubernetes, starting with / Getting started with Kubernetes
- microservices-based architecture
- reference link / Dawn of application architecture
- about / Dawn of application architecture
- Microsoft .NET Framework
- reference link / Monolithic architecture
- Minikube project
- references / Getting started with Kubernetes
- minions / Introducing Kubernetes
- monolithic applications
- to microservices / Monolithic applications to microservices
- monolithic architecture
- about / Monolithic architecture, Monolithic architecture
- presentation layer / Monolithic architecture
- business logic layer / Monolithic architecture
- persistence layer / Monolithic architecture
- application components / Application components
- monolithic layered architecture / When to use what
- mount
- used, for managing application states / Managing application states with mount
- reference link / Managing application states with mount
- enabling / Enabling mount
- Helping Hands, integrating with / Integrating with Helping Hands
- used, for initializing Apache Kafka / Initializing Kafka with Mount
- MySQL
- URL / Limitations
N
- namespaced keyword
- reference link / Interceptors
- naming conventions / Naming conventions
- Nimbus JOSE JWT library
- reference link / Using a Nimbus JOSE JWT library for Tokens
- non-functional requirements
- reference link / User stories
- nrepl
- reference link / Clojure IDE
O
- observer model / Observer model
- offset / Design principles
- Omniconf
- using, for configuration / Using Omniconf for configuration
- reference link / Using Omniconf for configuration
- enabling / Enabling Omniconf
- Helping Hands, integrating with / Integrating with Helping Hands
- one-time password (OTP) / Enabling authentication and authorization
- operational metrics
- publishing / Publishing operational metrics
- Order Component / Application components
- order workflow / Order workflow
P
- Pedestal
- concepts / Pedestal concepts
- Chain Providers / Pedestal concepts
- Network Connectors / Pedestal concepts
- interceptor / Interceptors
- interceptor chain / The interceptor chain
- Context Map, importance / Importance of a Context Map
- WebSocket, using / Using WebSocket with Pedestal and Jetty
- Pedestal architecture
- interceptors / Pedestal concepts
- Context Map / Pedestal concepts
- Pedestal project
- creating / Creating a Pedestal project
- Pedestal service
- creating / Creating a Pedestal service
- interceptors, using / Using interceptors and handlers
- handlers, using / Using interceptors and handlers
- routes, creating / Creating routes
- routers, declaring / Declaring routers
- request parameters, accessing / Accessing request parameters
- interceptors, creating / Creating interceptors
- exceptions, handling / Handling errors and exceptions
- errors, handling / Handling errors and exceptions
- logging / Logging
- operational metrics, publishing / Publishing operational metrics
- chain providers, using / Using chain providers
- Peer Server / Datomic versus traditional database
- Perl
- reference link / Monolithic applications to microservices
- permissions
- reference link / Using a Nimbus JOSE JWT library for Tokens
- persistence adapter
- creating / Creating a persistence adapter
- persistence layer / Monolithic architecture
- pods
- reference link / Introducing Kubernetes
- about / Introducing Kubernetes
- polling
- reference link / Using server-sent events (SSE)
- port / Hexagonal architecture
- Postal
- used, for email interceptor / Creating an email interceptor using Postal
- Postal library
- reference link / Integrating the Alert Service with Kafka
- presentation layer / Monolithic architecture
- pr function
- reference link / Logging
- principles
- configuring / Configuration principles
- configuration parameters, defining / Defining configuration parameters
- configuration parameters, using / Using configuration parameters
- production configuration
- reference link / Setting up Kibana
- protocol
- reference link / Pedestal concepts, Implementing Hexagonal Architecture
- publish-subscribe pattern
- reference link / Observer model, Using Kafka as a messaging system
- pull
- reference link / Using Datalog to query
Q
- quality assurance (QA) / Release cycle and the deployment process
- query
- reference link / Using Datalog to query
- query-params
- reference link / Accessing request parameters
- Query DSL
- reference link / Creating query interceptors
- query interceptors
- creating / Creating query interceptors
- query side / Using the CQRS pattern
- queuing
- reference link / Using Kafka as a messaging system
R
- range query
- reference link / Creating query interceptors
- read-eval-print-loop (REPL) / History of Clojure, REPL
- Registration Component / Application components
- regression
- reference link / CI/CD
- replication controller
- reference link / Introducing Kubernetes
- representational state transfer (REST)
- about / Introducing REST
- references / Introducing REST
- request map
- reference link / Importance of a Context Map
- keys / Accessing request parameters
- request parameters
- accessing / Accessing request parameters
- response map / Importance of a Context Map
- REST
- reference link / Direct messaging
- REST adapter / Hexagonal architecture
- REST APIs, for Helping Hands application
- about / REST APIs for Helping Hands
- Consumer and Provider APIs / Consumer and Provider APIs
- Service and Order APIs / Service and Order APIs
- RESTful APIs
- about / RESTful APIs
- status codes / Status codes
- naming convention / Naming conventions
- using, via cURL / Using RESTful APIs via cURL
- Ring framework
- reference link / Using interceptors and handlers
- router protocols
- reference link / Declaring routers
- routers
- declaring / Declaring routers
- routes
- creating / Creating routes
- reference link / Creating routes
- adding / Adding routes
- testing / Testing routes
- RRDTool
- reference link / Using ELK Stack with Collectd
- Ruby
- URL / Setting up Logstash
- Ruby on Rails
- reference link / Monolithic applications to microservices
S
- S-expressions
- reference link / Clojure and REPL
- Sagas
- reference link / Transactions
- sample.project.clj file
- reference link / Configuring a project
- scale cube model / Scaling
- scaling
- schema
- Scheme
- reference link / History of Clojure
- Separation of Concern (SoC)
- about / Monolithic architecture, Monolithic architecture
- reference link / Monolithic architecture
- SerDes
- reference link / Using Avro for data transfer
- server-sent events (SSE)
- about / Pedestal concepts, Using server-sent events (SSE) , Using WebSockets
- using / Using server-sent events (SSE)
- reference link / Using server-sent events (SSE)
- interceptors, creating / Creating interceptors for SSE
- server-side discovery pattern / Service discovery patterns
- service-oriented architecture (SOA)
- reference link / Data management
- about / Data management, Messaging and contracts
- service API port / Hexagonal architecture
- Service Component / Application components
- Service Consumer microservice
- creating / Creating a microservice for Service Consumer
- routes, adding / Adding routes
- Datomic schema, defining / Defining the Datomic schema
- persistence adapter, creating / Creating a persistence adapter
- interceptors, creating / Creating interceptors
- routes, testing / Testing routes
- service consumer workflow / Service consumer workflow
- service contracts / Service contracts
- service discovery
- about / Service discovery, Introducing Kubernetes
- service registry / Service registry
- patterns / Service discovery patterns
- service map
- reference link / Declaring routers
- Service microservice
- creating / Creating a microservice for Services
- routes, adding / Adding routes
- Datomic schema, defining / Defining a Datomic schema
- persistence adapter, creating / Creating a persistence adapter
- interceptors, creating / Creating interceptors
- interceptor, creating / Creating interceptors
- routes, testing / Testing routes
- Service Provider microservice
- creating / Creating a microservice for Service Provider
- routes, adding / Adding routes
- Datomic schema, defining / Defining Datomic schema
- persistence adapter, creating / Creating a persistence adapter
- interceptors, creating / Creating interceptors
- routes, testing / Testing routes
- service provider workflow / Service provider workflow
- service registry / Service discovery, Service registry, Service discovery patterns
- service workflow / Service workflow
- Servlet Chain Provider
- reference link / Accessing request parameters
- servlet interceptor
- reference link / Importance of a Context Map, Logging
- start-event-stream
- reference link / Creating interceptors for SSE
- stdin, Logstash
- reference link / Setting up Logstash
- stdout, Logstash
- reference link / Setting up Logstash
- Storage Service / Datomic versus traditional database
- SublimeREPL
- URL / Clojure IDE
- Sublime Text
- URL / Clojure IDE
T
- Table of Plugins
- reference link / Using ELK Stack with Collectd
- term query
- reference link / Creating query interceptors
- terms aggregation
- reference link / Getting status with aggregation queries
- test2junit
- reference link / Configuring a project
- tokens / Introducing Tokens and JWT
- Tomcat
- URL / Using chain providers
- tools.logging library
- reference link / Logging and monitoring guidelines
- topic / Design principles
- traditional database
- versus Datomic / Datomic versus traditional database
- Transaction Manager / Datomic versus traditional database
- Transactor
- about / Development model
- reference link / Development model
- Try Clojure
- URL / REPL
- Turing machine
- reference link / Dawn of application architecture
- twelve-factor methodology
- reference link / User stories
- Twitter
- reference link / Monolithic applications to microservices
U
- Undertow
- URL / Using chain providers
- union mount
- reference link / Introducing Containers and Docker
- usage instructions
- reference link / Enabling users and roles for authorization
- User Datagram Protocol (UDP)
- reference link / Using ELK Stack with Collectd
- user story
- reference link / Design
- about / User stories
V
- vector
- reference link / Creating routes
W
- WebSocket
- using / Using WebSockets
- using, with Pedestal / Using WebSocket with Pedestal and Jetty
- using, with Jetty / Using WebSocket with Pedestal and Jetty
- with-bindings
- reference link / Importance of a Context Map