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
  • about / Boot
  • references / 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
  • about / Scaling
  • reference link / Scaling
• schema
  • about / Schema
  • reference link / 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