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.
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.
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.
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.
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 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.
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.
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.
In this article, we will setup our environment to deploy the reference implementation to Amazon's Kubernetes service, EKS.
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.
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.
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.
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.
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.