Centralizing Configurations with Spring Cloud Config

Bing Liu Microservices, Spring Boot, Technology Snapshot Leave a Comment

When the Microservices approach became popular a few years ago, many companies rushed to build their own microservices or to convert their legacy applications into microservices. Over the years, companies have implemented an abundance of microservices, mostly with Spring Boot. Each of them manage their own configurations across deployment environments like Dev, Test, and Prod.

Due to the nature of a complex business process, there are many common configurations (e.g. databases, queues, email servers, and FTP servers, etc.) used in the distributed services. This can result in services having redundant and confusing configs on a distributed system. It can become challenging to update the configs for too many services on a distributed system across multiple environments.

Thankfully, Spring Cloud Config provides the implementation to successfully resolve these issues. It provides server-side and client-side support for externalized configuration in a distributed system. With the Config Server, you have a central place to manage external properties for applications across all environments. The concepts on both client and server map identically to the Spring Environment and PropertySource abstractions, so they fit very well with Spring applications.

In this post, I’ll demonstrate Config Server and Client with example code. I’ll show you how to use Git or a local repository as a central place to store all the config files. The diagram below illustrates how the distributed client services (e.g. Investment Position/Price/Reporting Data service) fetch their configuration from the Config Server, which in turn retrieves them from one central place.

A Vue of Python

Chris Berry JavaScript, Node, Python, Technology Snapshot, Vue Leave a Comment

Earlier this year I blogged about creating a Lean Mean Vue Machine called Quotes on Demand. The application was a fully featured CRUD application served from a NodeJS server and had a self contained VueJS front end.

But wouldn’t it be a nice test to see if that same Vue application could switch over to another API, say something like a Python web server powered by Flask?

In this post, we will create a Python web application that will have 100% parity to an existing NodeJS web application. This will enable an existing VueJS front end to connect to the application with no additional code changes in the user interface code.

JSON Web Token .NET Core Demo

Lou Mauget .NET Core, C#, Programming, Technology Snapshot Leave a Comment

In this post, I present a tiny .NET Core C# JWT API demo that creates and parses a JSON Web Token (JWT). A self-contained Swagger UI dashboard exercises the API. 

We can’t dead-drop a JWT demo without wrapping it in words about JWT background. I’ll set the scene by introducing tokens, JWTs, and surveying session state residency tradeoffs. We’ll then migrate to, high-level JWT JWT use cases, and arguments about if or when to use JWTs. 

I seek to give equal coverage to JWT upsides and downsides. Let’s get started.

[Video] Azure Options For Enterprise: Pros, Cons & Use Cases

Keyhole Software .NET, Azure, Cloud, Keyhole, Service Fabric, Technology Snapshot, Tutorial, Video Leave a Comment

The Azure cloud platform is vast and it can be difficult to determine the best option given unique requirements. This video discusses six options within the wide world of Microsoft Azure including Virtual Machines (IaaS), App Services (PaaS), Function Apps (FaaS), AKS (KaaS), Logic Apps (?aaS), and Service Fabric (PaaS).

For each option, Keyhole Software Consultant Zach Gardner introduces the pros, cons, optimal use cases, and tips for success with each Azure approach based on his experience.

This 40-minute video was recorded in November 2019 at a Keyhole Software internal employee Lunch & Learn event featuring Keyhole Consultant Zach Gardner…

Maps and Entities and JPA, OH MY!

Ryan McCullough Problem Solving, Programming, Technology Snapshot Leave a Comment

A client I’m working with has an email templating system that needs an upgrade! The current design utilizes a denormalized table that needed to grow a column every time a new unique token is needed. After a review of the offerings through JPA, I was happy to see that JPA had some support for java.util.Map through joins through a variety of the @MapKey annotation.

In this post, I’ll demonstrate the less frequently used methodology of applying and populating a Map of entities using a single table and a composite key.