ThinkMicroservices.com

  •  Home
  •  News
  •  Archive
  •  Reference Implementation
  •  Resources
  •  Subscribe
  • Search
  • Menu
  •  Home
  •  News
  •  Archive
  •  Reference Implementation
  •  Resources
  •  Subscribe

    Recent Posts

  • Object Caching, Redis, and Kubernetes

  • Object Storage, Minio, and Kubernetes

  • OpenFaaS NATS Event Connector

    Archive

    Here you will find each article presented in chronological order. The articles have been organized and published in a logical sequence to help guide the reader through the material.


    June 2019

    • 01 - Rage Against The Monolith

      Monolithic architectures have been the dominant model for application development for a long time. In this article, we discuss the common pain points encountered when building monolithic applications.

        monolith microservice microservices scalability coupling fragility

    • 10 - Microservice introduction

      In the previous article, we discussed the common pain points encountered when developing monolithic applications. In this article, we introduce the "Microservice" model to address them.

        SOA microservices architecture governance communication

    • 17 - Principles of Isolation

      The concept of isolation plays an important role when building microservice architectures. This article focuses on four dimensions of isolation: State, Space, Time, and Failure.

        isolation eventual consistency

    • 28 - Laws of Scalability

      When building microservices, it is important to understand the concepts of resource contention, linear scaling, Amdahl's law, Gunther's law, and coherency delay.

        scalability Amdahl's Law Gunther's Law coherency delay contention linear scaling

    July 2019

    • 02 - Domain Driven Design

      A microservice application is a collection of services. When designing a microservice application, a critical step is deciding the responsibilities of each service. One approach that has gained considerable traction in the microservice community is Domain Driven Design. In this article we provide a high-speed introduction to Domain Driven Design, its relevant terminology, and definitive references.

        DDD Domain Driven Design domain design architecture bounded context ubiquitous language aggregate root

    • 10 - Hexagonal Architecture

      When developing an individual microservice, it is advantageous to isolate the core business logic from both the mechanisms that access it and the systems it accesses. In this article we introduce the reader to Alistair Cockburn's Hexagonal Architecture (A.K.A. Ports and Adapters) approach.

        Hexagonal Architecture Ports and Adapters domain ports adapters domain

    • 18 - Reactive Microservices

      The requirements of modern applications force developers to make fundamental changes in how we construct applications. In this article, we will look at the Reactive Microservice approach. This approach focuses on four guiding attributes: Responsiveness, Resiliency, Elasticity, and Message-Driven.

        reactive microservices elastic message-driven resilient

    • 21 - Microservice disadvantages

      Full Disclosure... Microservice architectures are not all rainbows and unicorns. Beyond all the hype and hyperbole, microservices are just distributed systems, and distributed systems are difficult.

        microservice disadvantages distributed computing fallacies

    August 2019

    • 02 - CAP Theorem

      Microservices architectures naturally imply a move from vertical to horizontal scaling. This scaling change requires the developer to address three core traits: Consistency, Availability, and Partition Tolerance. This article will introduce the CAP theorem, which seeks to explain the relationship between the three characteristics.

        CAP Theorem consistency availability partition tolerance strong consistency eventual consistency

    • 09 - Sharding

      Consistency creates contention, and contention negatively impacts application scalability. This article introduces the concept of Sharding to reduce contention probability while still maintaining consistency in a distributed environment.

        Sharding consistency scalability contention shard balancing availability

    • 17 - Conflict-Free Replicated Data Types

      In the previous article, we saw how Sharding addresses issues with contention. This article will introduce a technique to increase availability: Conflict-free replicated data types or CRDTs.

        CFRDT availability scalability replication

    • 28 - Message-Driven Microservices

      When developing applications, there is a common expectation that the caller will wait for the result to be returned. This synchronous approach is usually more straightforward programmatically but comes at the cost of idle resources. An alternate approach is to introduce an asynchronous communication model built around messages and message queues. This article introduces the reader to Message-Driven Microservices

        Message Driven microservices

    September 2019

    • 01 - From Transactions to Sagas

      In a microservice application, it is common for services to manage their own entity stores. Complications arise for operations that must span multiple services. When this occurs, the complexity involved in managing the distributed transaction can seriously impact performance. This article introduces the Saga pattern to address this situation.

        saga two-phase commit distributed transactions

    • 21 - Event Sourcing

      It is a fact of life that applications will have defects. The process of remediating an error is straightforward. Write a unit test to reproduces the defect (if one doesn't already exist) and then modify the defective source code until the unit test passes. But how do we fix data that has been corrupted by the faulty code? If we use the common CRUD approach, we store only the current state of an entity. In this situation, we have no way of knowing how we arrived at that state. This article explores the Event Sourcing approach as a means to address the problem.

        Event Sourcing Event Streams CRUD events snapshots

    October 2019

    • 14 - Command Query Responsibility Segregation

      In the previous article, we introduced Event Sourcing and identified one of the primary disadvantages of event sourcing when a single aggregate root couldn't answer our queries. In this article, we present a solution to the problem: Command Query Request Segregation.

        CQRS commands events queries

    • 15 - Service Discovery

      How does a client find its service in a microservice application where we have elasticity and dynamic deployment? In this article, we introduce the Service Discovery pattern to address this problem.

        service discovery service registery pattern

    • 25 - API Gateway Pattern

      When building microservices applications, it is not practical to expose individual services directly to the application client. Instead, it is often advisable to introduce a mediator between the client application and its desired services. In this article, we present the "API Gateway" pattern.

        api gateway pattern

    November 2019

    • 03 - Retry Pattern

      All applications, regardless of their architecture, must embrace the idea that failure is an option. We can count on hardware and networks to fail, so we must code for these failures. However, most failures are not terminal. Given sufficient time, many failures are recoverable. In this article, we introduce the Retry pattern as an approach to gracefully recover from failure.

        retry pattern

    • 10 - Circuit Breaker Pattern

      In the previous article, we introduced the Retry Pattern for recoverable failures. However, what do we do when a failure isn't recoverable? This article will look at the Circuit Breaker Pattern and how it applies to failures.

        circuit breaker pattern

    • 17 - Microservices and Containers

      Managing an extensive collection of services directly in production can be difficult. In this article, we introduce service containerization to begin addressing this problem.

        container Docker

    • 24 - Microservice Container Orchestration

      Containerized services simplify the deployment and management of individual services. However, how do you manage an application composed of hundreds of containerized microservices? In this article, we introduce Container Orchestration to simplify the process.

        container Docker Swarm orchestration Kubernetes

    December 2019

    • 02 - Microservice Monitoring

      In an application composed of tens, hundreds, or even thousands of services, how can you determine when a service is under stress or has stopped working. In this article, we will introduce Microservice Monitoring to provide insight for troubleshooting and analysis.

        monitoring

    • 12 - Microservices Logging

      In a monolithic application executing in a single process, it is a relatively trivial exercise to troubleshoot the application from its log files. But how do you troubleshoot a distributed application that may have hundreds of log files? In this article, we introduce distributed logging to a microservice application.

        logging fluentd Elastisearch Logstash Kibana

    • 19 - Microservices Configuration

      When our application runs in a single execution environment, a simple local configuration file may be sufficient to provide configuration. However, when our application's services span multiple machines, data centers, and geographic regions, local configuration files are inadequate. In this article, we introduce the concept of a Configuration Service to handle application configuration.

        configuration configuration profile

    • 26 - Microservice Authentication & Authorization

      Monolithic applications resources share the same execution environment. This attribute allows the application's resources to share a common authentication and authorization mechanism. However, in a microservice, each service runs in its own execution environment and cannot share a common authentication and authentication mechanism. This article introduces an approach that divides the authentication and authorization responsibilities in the application. Authentication is handled by an Authentication Service that verifies a user's credentials and issues the caller a JSON Web Token (JWT), representing the authenticated user. Any service that contains secured resources is responsible for handling access authorization. The service performs access authorization by comparing claims contained in the JWT against the required resource privileges.

        authentication authorization JWT

    January 2020

    • 10 - Building a Microservice reference implementation

      In this article, we begin applying what we have learned from previous articles to create a Reference Architecture. The Reference Architecture outlines the infrastructure and services needed to construct the common foundations of a microservice application.

        reference implementation infrastructure logging event bus message bus persistence PostgreSQL MongoDB Fluentd Elasticsearch Kibana Prometheus Grafana monitoring

    • 17 - A Spring-Based Reference Implementation

      In the previous article, we outlined a Reference Architecture of our foundational microservice application. To realize this architecture, we have selected Java as our implementation language. Additionally, we will leverage the Spring framework's various features to support our microservice implementation. This article provides a brief history of the Spring framework and why it was selected.

        Spring Spring Boot Spring Cloud Spring Actuator

    • 21 - Development Toolbox

      Before we start building our first service, we will need to select a few more tools. This article will cover a selection of tools we will be using for our Spring reference implementation.

        Lombok Maven SDKMan Docker Docker-Compose Fluent Portainer Java Swagger SpringFox Micrometer Portainer

    • 27 - Configuration Service & Unified Logging

      In this article, we will start constructing our reference implementation. We will implement our first service and set up the applications distributed logging and monitoring infrastructure. We begin by building the ConfigurationService, which externalizes and centralizes the application's configuration. While building the service, we introduce Spring Actuator, Micrometer, and Prometheus to capture and store the service's metrics and Grafana to render the application's metrics. Distributed logging is handled using a combination of Fluentd, Elasticsearch, and Kibana to capture, index, and query log data. Finally, we orchestrate our service and its supporting infrastructure with Docker-Compose.

        Spring Cloud Spring Config Docker Docker-Compose Fluentd Elasticsearch Kibana Prometheus Grafana

    • 30 - Discovery Service

      Microservice applications are generally composed of a large number of services which must communicate with each other. However, to communicate with another service, we must first know its location and port. In this article, we implement a "Discovery Service" that services can both register their availability and query to find other services.

        Discovery Service Eureka

    February 2020

    • 05 - Content Service

      It is a common requirement for applications to serve static content. This requirement can be fulfilled by a content delivery network (CDN), web-enabled object-store (e.g., Amazon S3, IBM Cloud Object Storage, Digital Ocean Spaces) or a web server. This article will build a simple Spring-based Content Service to serve the application's static assets.

        Content Spring service

    • 10 - API Gateway Service

      Microservices applications are composed of many services, each with a unique host and port. Rather than directly exposing each service to an application client, it is usually preferable to provide a single endpoint service that performs client service queries and handles service request and response proxying. In this article, we will build the API Gateway Service. It leverages the Spring Cloud Gateway project to support declarative routing, service query, and load balancing.

        API Gateway Service api gateway spring cloud

    • 16 - Outbound Email Service (Part 1)

      A common requirement for many applications is the ability to send email messages. In this first part of a two-article series, we build the OuboundEmailService. The service receives outbound email requests via REST endpoint and Message Queue listener and sends them to a configured email provider. This article will focus look at the service models, and the core logic for sending email messages. We will configure Swagger to allow us to exercise the service endpoint, and also discuss service Internationalization (I18N).

        Outbound Email Service Swagger SpringFox REST message-driven RabbitMQ Spring Cloud Stream I18N Internationalization

    • 20 - Outbound Email Service (Part 2)

      This article will finish construction of the OutboundEmailService by implementing the service's REST controller and MessageQueue listener. We will use Docker-Compose to deploy the service. Once the service starts, we exercise the REST endpoint using the service's Swagger user interface and send messages to the service's message queue via RabbitMQ's web interface. We complete the article by viewing the service's operational metrics using Grafana.

        Outbound Email Service Swagger SpringFox REST message-driven RabbitMQ Spring Cloud Stream I18N Internationalization

    • 26 - Outbound SMS Service

      Another common requirement for modern applications is the support of SMS/MMS messaging. In this article, we will build OutboundSMSService, which parallels the structure and implementation of the service by including both a REST Controller endpoint and a MessageQueue listener. We supplement this architecture with a pluggable provider interface to support multiple options when selecting a messaging service provider. This article will be implementing a Twilio service provider implementation to demonstrate integration with a third-party messaging service. We will exercise the REST endpoint the generated Swagger ui, and we will use RabbitMQ to enqueue messages for OutboundSMSService to consume. We end the article by viewing the OutbounndSMSService's operation metrics using a Grafana dashboard.

        Outbound SMS Service

    March 2020

    • 01 - Notification Service

      In the previous three articles, we created two services, the OutboundEmailService and the OutboundSMSService. Both of these services can be called directly via their respective REST endpoints. However, Calling these services directly can potentially cause contention when the service is under heavy load. We did, however, anticipate this situation when creating the services by including a message queue listener. In this article, we will build the NotificationService, which accepts both email and SMS/MMS message requests, and enqueues the message in the respective message queue topics. This approach reduces the concurrent load on each of the messaging services. After the NotificationService is constructed, we will exercise it using its generated Swagger interface, and view its operational metrics using the corresponding Grafana dashboard.

        Notification Service message queue Swagger Grafana

    • 05 - Authentication Service (PART I)

      Most applications require some form of authentication to restrict access to secured various service features. Additionally, we need a mechanism to register users and recover a user's forgotten passwords. To fulfill these requirements, this will be the first of a four-part series of articles cover the construction of the AuthenticationService. In this article, we introduce the basic components of the AuthenticationService.

        Authentication Service Spring JWT authentication authorization

    • 10 - Authentication Service (PART II)

      In this second article discussing the AuthenticationService, we cover several areas. First, we introduce the user credentials and privileges role data model and the Spring repositories used to persist the data. We also look at the service's event publisher, the JSON Web Token (JWT) provider, and the email client the service uses to send messages to the Notification Service.

        Authentication Service Spring JWT Notification Service

    • 15 - Authentication Service (PART III)

      In this third article discussing the AuthenticationService, we focus on the implementation of the core logic found in the AuthenticationService class and the JWTAuthorizationFilter, which intercepts service requests and verifies that each request has sufficient privileges to access the resource.

        Authentication Service Spring JWT authorization Grafana dashboard

    • 17 - Authentication Service (PART IV)

      In this fourth and final article discussing the AuthenticationService, we will exercise the service using its generated Swagger interface, and we view its operation metrics using the AuthenticationDashboard in Grafana.

        Authentication Service Spring Swagger Springfox api gateway gateway

    • 20 - Account Profile Service

      For every registered user in the application, there exists a corresponding profile that contains application-specific information for that user. In this article, we construct the AccountProfileService, which is responsible for managing this data. The service provides a REST endpoint as well as a MessageQueue listener and persists the profile data in a MongoDB database. We will deploy the application and exercise its REST endpoint using the generated Swagger user interface. We wrap up by viewing the operational metrics using the AccountProfile Grafana dashboard.

        Account Profile Service Swagger Grafana dashboard

    • 26 - Account History Service

      During the lifetime of every user account, various events are generated and published to the application's message queue. It is advantageous to capture and persist these events to provide an audit log of an account's activity. In this article, we will build the AccountHistoryService which performs this task. In addition to capturing the account events, the service also provides a REST endpoint to query these events. After construction, we will deploy the application and exercise the generated Swagger interface. We then view the operational metrics using the AccountHistory Grafana dashboard.

        AccountHistoryService REST Swagger Spring Grafana dashboard

    April 2020

    • 10 - Administration Service

      Every application needs an administration console, and ours is no exception. In this article, we will build the AdministrationService to provide users with administration privileges to view, query, and control, various aspects of the application. Once constructed, we will exercise the service's Swagger interface and view the service's operational metrics using the AdministrationDashboard in Grafana.

        Adminstration Service Swagger REST Grafana dashboard

    • 20 - Telemetry Service

      Throughout the construction of the microservice reference implementation, we have had access to our services aggregated logging and operational metrics. It would be advantageous to extend this visibility beyond the boundary of the backend to our application clients. This article constructs the TelemetryService. This service provides application clients with an endpoint where they can log operational messages for troubleshooting and analysis.

        Telemetry Service telemetry REST Swagger

    • 24 - Feature Service

      When building and deploying application clients, controlling the visibility of various runtime features can simplify client deployment and testing. In this article, we will build the FeatureService which allows an application to query the service for a set of runtime feature toggles. These feature toggles can be used by the application client to enable or disable selected features.

        Feature Service feature flag feature toggle REST Swagger

    May 2020

    • 04 - Peer-Signaling Service

      In a Post-Covid19 world, the need for integrated peer to peer, streaming audio and video service in modern applications will become an increasingly more common requirement. In this article, we build a PeerSignalingService to support a WebRTC-based application client's point-to-point video chat feature.

        Peer-Signaling Service WebRTC Video WebSocket

    • 25 - Angular Application Client

      In the last article, we completed the core services for our reference implementation. This article introduces the reader to an example application client built using the Angular framework. This application client demonstrates how a web application can be used to exercise the reference implementation's features. Construction of the application client is out of scope for the article, but the Angular client's source code is available for interested readers.

        Angular Application Client SPA Angular WebRTC

    June 2020

    • 11 - From Docker-Compose to Kubernetes Part I. Kompose

      In this article we look at the relevent subset of Kubernetes API objects that we will need to understand when deploying the reference implementation. We then introduce Kubernetes Kompose to do the bulk of the translation from our docker-compose.yaml file into appropriate Kubernetes manifests.

        Kubernetes orchestration microk8s minikube K8S kubectl kompose

    • 20 - Docker Compose to Kubernetes part II.

      With a working Kubernetes environment and a basic knowledge of the differences between , we spend this article becoming familiar with the differences between Docker Compose and Kubernetes.

        Kubernetes orchestration microk8s K8S Kompose kubectl

    July 2020

    • 05 - Docker Compose to Kubernetes part III

      Now that we have a working Kubernetes environment, we need to convert our Docker Compose file into a form Kubernetes can work with. In this article, we introduce the Kubernetes Kompose tool, which will help us accomplish this task.

        Kubernetes orchestration microk8s K8S Kompose kubectl

    August 2020

    • 15 - Packaging Kubernetes applications with Helm

      Helm is the package manager for Kubernetes. In this article, we will introduce basic Helm concepts and then use these concepts to package the reference implementation application.

        Kubernetes orchestration microk8s K8S Helm kubectl

    September 2020

    • 15 - Deploying Helm charts to Amazon EKS

      In this article, we will setup our environment to deploy the reference implementation to Amazon's Kubernetes service, EKS.

        Kubernetes orchestration eks K8S Helm kubectl AWS CLI eksctl

    October 2020

    • 12 - Microservices, Function-as-a-Service, and Kubernetes

      In this article, we introduce Functions As A Service (FaaS) and discuss the idea that we can consider Functions as the minimalist approach to microservices. We will explain the architectural motivation for FaaS, and introduce OpenFAAS, a Kubernetes-friendly FaaS framework.

        Kubernetes openfaas functions serverless

    November 2020

    • 17 - Accessing Kubernetes Programatically

      While kubetctl allows developers and operations to control Kubernetes clusters, it may be necessary to interact with your Kubernetes instances programatically. In this article, we will explore the using the Kubernetes Java Client API provided by Fabric8.

        Kubernetes microk8s REST fabric8

    December 2020

    • 12 - Kubernetes and ContainerD

      Kubernetes will be deprecating the use of Docker after version 1.20 and support is slated from removal by late 2021. In its place, Kubernetes will default to containerd.

        Kubernetes docker containerd dockershim microk8s

    January 2021

    • 12 - Service Meshes, Kubernetes, and Linkerd

      In this article, we introduce the Service Mesh pattern to handle inter-service communication. We also introduce Linkerd as our example Service Mesh and demonstrate its use with a MicroK8S Kubernetes instance.

        Kubernetes service mesh Linkerd

    February 2021

    • 17 - Speeding up Java with GraalVM

      When selecting a language for microservice development, a common complaint leveled against Java is its slower startup time and large memory footprint. In this article, we address these concerns with the introduction of the GraalVM and GraalVM Native Image.

        Spring Spring Boot Spring Native GraalVM native image

    March 2021

    • 18 - Spring goes Native

      After 18 months of development, the Spring framework has finally release the Spring Native (beta). Spring Native allows the Spring Framework to leverage the reduced startup time and lower memory footprint of the GraalVM Spring Native support.

        Spring Spring Boot Spring Native GraalVM native image Dive

    May 2021

    • 17 - RSocket Microservices

      While REST is the most common way to access a microservice, other alternative approaches do exist. In this example we will introduce rsocket, and explain how to use it to expose your service.

        rsocket REST

    June 2021

    • 15 - NATS Messaging

      Message-Driven architectures need a messaging platform. In this article, we introduce NATS Messaging, discuss its supported messaging patterns, demonstrate how to scale NATS using clustering, and implement three Spring Boot services to demonstrate NATS client integration.

        NATS Kubernetes

    July 2021

    • 12 - NATS JetStream

      In the previous article we introduced NATS Messaging and its core messaging patterns. In this article, we look at NATS messaging streaming support with NATS JetStream and demonstrate JetStream integration with a simple Spring Boot REST service.

        NATS Kubernetes JetStream

    August 2021

    • 10 - OpenFaaS NATS Event Connector

      In the previous two articles we discussed the NATS and its message streaming progeny JetStream. In this article we will demonstrate how we can configure NATS to deliver messages to an OpenFaaS instance on MicroK8s.

        NATS Kubernetes OpenFaas Event Connector

    September 2021

    • 30 - Object Storage, Minio, and Kubernetes

      The ephemeral nature of microservices and their containers poses challanges for storing application state. In this article we look at using an object-store (Minio) and demonstrate how we can access it from a Spring-Boot service. We start by deploying a Docker-ized instance ofMinIO as our Spring-Boot object-store and then deploy the MinIO Kubernetes operator using Krew in a MicroK8s instance.

        Minio Kubernetes microstorage

    March 2022

    • 15 - Object Caching, Redis, and Kubernetes

      The ephemeral nature of microservices and their containers poses challanges for storing application state. In this article we look at using an object-cache (Redis) and demonstrate how we can access it from a Spring-Boot service. We start by deploying a Docker-ized instance ofRedis as our Spring-Boot object-cache and deploy the Redis Kubernetes operator .

        Redis caching

Think Microservices

Think Microservices

Microservices not Monoliths.

    Recent Posts

    If you are just getting started with microservices, consider starting with the first article: Rage Against the Monolith.
  • Object Caching, Redis, and Kubernetes

    Mar 15, 2022
  • Object Storage, Minio, and Kubernetes

    Sep 30, 2021
  • OpenFaaS NATS Event Connector

    Aug 10, 2021
    • View more posts

Tags

  • AccountHistoryService (1)  
  • Account Profile Service (1)  
  • adapters (1)  
  • Adminstration Service (1)  
  • aggregate root (1)  
  • Amdahl's Law (1)  
  • Angular (1)  
  • Angular Application Client (1)  
  • api gateway (2)  
  • api gateway gateway (1)  
  • API Gateway Service (1)  
  • architecture (2)  
  • authentication (2)  
  • Authentication Service (4)  
  • authorization (3)  
  • availability (3)  
  • AWS (1)  
  • bounded context (1)  
  • caching (1)  
  • CAP Theorem (1)  
  • CFRDT (1)  
  • circuit breaker (1)  
  • CLI (1)  
  • coherency delay (1)  
  • commands (1)  
  • communication (1)  
  • configuration (1)  
  • configuration profile (1)  
  • consistency (2)  
  • container (2)  
  • containerd (1)  
  • Content (1)  
  • contention (2)  
  • coupling (1)  
  • CQRS (1)  
  • CRUD (1)  
  • dashboard (4)  
  • DDD (1)  
  • design (1)  
  • Discovery Service (1)  
  • distributed computing fallacies (1)  
  • distributed transactions (1)  
  • Dive (1)  
  • docker (1)  
  • Docker (4)  
  • Docker-Compose (2)  
  • dockershim (1)  
  • domain (2)  
  • Domain Driven Design (1)  
  • eks (1)  
  • eksctl (1)  
  • elastic (1)  
  • Elasticsearch (2)  
  • Elastisearch (1)  
  • Eureka (1)  
  • event bus (1)  
  • Event Connector (1)  
  • events (2)  
  • Event Sourcing (1)  
  • Event Streams (1)  
  • eventual consistency (2)  
  • fabric8 (1)  
  • feature flag (1)  
  • Feature Service (1)  
  • feature toggle (1)  
  • Fluent (1)  
  • fluentd (1)  
  • Fluentd (2)  
  • fragility (1)  
  • functions (1)  
  • governance (1)  
  • GraalVM (2)  
  • Grafana (7)  
  • Gunther's Law (1)  
  • Helm (2)  
  • Hexagonal Architecture (1)  
  • I18N (2)  
  • infrastructure (1)  
  • Internationalization (2)  
  • isolation (1)  
  • Java (1)  
  • JetStream (1)  
  • JWT (4)  
  • K8S (5)  
  • Kibana (3)  
  • kompose (1)  
  • Kompose (2)  
  • kubectl (5)  
  • Kubernetes (14)  
  • linear scaling (1)  
  • Linkerd (1)  
  • logging (2)  
  • Logstash (1)  
  • Lombok (1)  
  • Maven (1)  
  • message bus (1)  
  • message-driven (3)  
  • Message Driven microservices (1)  
  • message queue (1)  
  • microk8s (6)  
  • Micrometer (1)  
  • microservice (1)  
  • microservice disadvantages (1)  
  • microservices (3)  
  • microstorage (1)  
  • minikube (1)  
  • Minio (1)  
  • MongoDB (1)  
  • monitoring (2)  
  • monolith (1)  
  • native image (2)  
  • NATS (3)  
  • Notification Service (2)  
  • openfaas (1)  
  • OpenFaas (1)  
  • orchestration (6)  
  • Outbound Email Service (2)  
  • Outbound SMS Service (1)  
  • partition tolerance (1)  
  • pattern (4)  
  • Peer-Signaling Service (1)  
  • persistence (1)  
  • Portainer (1)  
  • ports (1)  
  • Ports and Adapters (1)  
  • PostgreSQL (1)  
  • Prometheus (2)  
  • queries (1)  
  • RabbitMQ (2)  
  • reactive (1)  
  • Redis (1)  
  • reference implementation (1)  
  • replication (1)  
  • resilient (1)  
  • REST (8)  
  • retry (1)  
  • rsocket (1)  
  • saga (1)  
  • scalability (4)  
  • SDKMan (1)  
  • serverless (1)  
  • service (1)  
  • service discovery (1)  
  • service mesh (1)  
  • service registery (1)  
  • shard balancing (1)  
  • Sharding (1)  
  • snapshots (1)  
  • SOA (1)  
  • SPA (1)  
  • Spring (9)  
  • Spring Actuator (1)  
  • Spring Boot (3)  
  • spring cloud (1)  
  • Spring Cloud (2)  
  • Spring Cloud Stream (2)  
  • Spring Config (1)  
  • Springfox (1)  
  • SpringFox (3)  
  • Spring Native (2)  
  • strong consistency (1)  
  • Swagger (10)  
  • Swarm (1)  
  • telemetry (1)  
  • Telemetry Service (1)  
  • two-phase commit (1)  
  • ubiquitous language (1)  
  • Video (1)  
  • WebRTC (2)  
  • WebSocket (1)  
All Tags


About

ThinkMicroservices.com is a resource for understanding Microservices.

© ThinkMicroservices.com. Sitemap.