DEV Community: FaN000s

[Boost]

FaN000s — Wed, 22 Apr 2026 08:32:53 +0000

Mohammad Awwaad

Apr 21

Building a Local, Zero-Cost AI Pull Request Reviewer with LangGraph and Ollama

#ai #python #devops #architecture

Comments

6 min read

[Boost]

FaN000s — Sun, 08 Mar 2026 19:33:41 +0000

The Zero-Cost Cloud Engineer: The $300 Dilemma and Provisioning the Free VM

Mohammad Awwaad ・ Mar 8

#gcp #devops #architecture #springboot

When was the last time you have implemented one of the design patterns? what was the problem you were trying to solve?

FaN000s — Sat, 15 May 2021 07:55:05 +0000

There are a lot of resources out there explain the different kinds of design pattern. Most (if not all) these resources are based on imaginary scenarios for simplification.

So, what about sharing the last time you have implemented one of the design patterns in a real world project?

Introduction to Spring Cloud Config

FaN000s — Sat, 14 Nov 2020 20:48:08 +0000

In my previous article I have mentioned four products/applications for managing configuration in microservices architecture. In this article we will explain the first option (Spring Cloud Config)

What is spring cloud config

Spring cloud config is part of spring cloud tool set for developing cloud native application and microservices. It provides server and client support for externalize configurations in a distributed systems.

In much simpler words, spring cloud config is a normal spring project that reads configurations from a centralized configuration repository and provides these configuration to other application (microservices).

Setting up the config server.

Getting spring cloud config server is easy as much as creating any other spring project.

Go to start.spring.io
Set the project name (Artifact) to config-server and in the dependencies section add config server.
Download the zipped file (config-server.zip).
Extract the project $ unzip config-server.zip.
In the ConfigServerApplication class add @EnableConfigServer annotation.



package com.example.configserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {

    public static void main(String[] args) {
         SpringApplication.run(ConfigServerApplication.class, args);
    }
}

Execute the following commands to create a local git repository. This git repository will be used by the spring config server as the source of configuration for the other service. ```

$mkdir config-repo
$cd config-repo
$echo "foo.property=property_dev_value" > my-service-dev.properties
$echo "foo.property=property_sit_value" > my-service-sit.properties
$echo "foo.property=property_prod_value" > my-service-prod.properties
$git init
$git add .
$git commit -m"Adding configurations"

* Add the following properties to the `application.properties` file.

spring.cloud.config.server.git.uri=file://${user.home}/config-repo
spring.cloud.config.server.git.clone-on-start=true

* Build the project `$ cd config-server && mvn clean package`.
* Run the project `$ java -jar target/config-server.VERSION.jar`.

Now you have a full featured configuration server up and running. 


## Creating a spring boot client application.
Now we need to create another application that will act as a microservices that needs to load its configuration from our configuration server. 
Obviously we will use spring boot and the other part of spring cloud config project (the client library).
<br/>
There are two points we need to mention here before getting into the steps of creating the client. 
1. As the configuration of any project usually needs to be loaded at the startup process, we need to change the behavior of application bootstraping. This happens just by adding a new file `bootstrap.properties` to the resources directory.  
2. The link between the client application and the config server is the application name. In our case `my-service`. 

<br/>
Here are the steps needed to create a client application.
* As usual, go to [start.spring.io](https://start.spring.io/)
* set the project name (Artifact) to my-service.
* add `config client` to the dependencies.
* Change `MyserviceApplication.java` class to be as following

package com.example.myservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;

@SpringBootApplication
@RefreshScope
public class MyserviceApplication {

public static void main(String[] args) {
    SpringApplication.run(MyserviceApplication.class, args);
}

}

* Add `bootstrap.properties` file to the resource directory and write the following configuration into it.

server.port=8081
spring.application.name=my-service
spring.cloud.config.uri=http://localhost:8080

The `spring.cloud.config.uri` property is pointing to the URL of the config server.
* For testing, we will create a REST controller `ConfigController`, inject a value from the properties files in the configuration server (`foo.property`), then display the value. For that purpose, create the following class.

package com.example.myservice;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigController{

@Value("${foo.property: nothing}")
private String configProperty;


@GetMapping("/getConfigs")
public String getConfigProperty(){
    return this.configProperty;
}

}


* Package the client application `$mvn clean package`
* Run the client application `$java -jar target/myservice.VERSION.jar`.
<BR/>
Now if you open this URL (http://localhost:8081/getConfigs) in the browser, you should see the value of the `foo.property` displayed. 
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/xp63h0m3czon8m4sc19o.png)
* If you want to get the configuration of another profile, you have to set the `spring.profiles.active` property in the `bootstrap.properties` file.

spring.profiles.active=prod

Now if you package and rerun the application, you will get the value of the same property from the `prod` profile.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/qeww2q7ws04axxz3ackm.png)
<br/>
<br/>

## Final note.
At the time of writing this article, I faced an issue getting the client up and running using spring boot version `2.4.0`. I had to use the previous stable version `2.3.6`.

Managing configurations in microservices

FaN000s — Fri, 23 Oct 2020 15:33:41 +0000

Disclaimer
This post is part of a weekly writing challenge. Two of my friends and I agreed on holding a writing challenge in order to gain the writing habit as well as improving our writing skills.

Introduction

In the age of cloud environments and microservices architecture, a need to different way to mange the configurations for application/application instances has appeared.

For that purpose, software architects have many options to choose from. In this article we will talk briefly about some of the available options. In the next parts of this article we will go through each option in some details.

The solutions we will talk about are

Spring cloud config server
Central Dogma
Consul
Kubernetes ConfigMap and Secrets

Spring cloud config

Spring cloud config is part of spring cloud tools that provides the ability to externalize the configurations in a distributed systems. The project consists of two parts, a config server and a config client.
The config server is a simple spring boot application. It reads the configuration from a configuration repository and provides it to clients. The configuration server can be a directory on your file system, a git repository, or the HashiCorp Vault tool.

You can store the configuration in either yaml or .properties and read it in yaml, properties, or json.

Spring cloud config server also provides a REST API for the configuration, hence you can use it from any other technology.

Central Dogma

Central dogma is an open source configuration server based on git and zookeeper.
Central dogma works almost the same way as spring cloud config server. It reads the configurations from a configuration repository (git in this case) and provides them via REST Api, client library, and command line tool.
Central dogma has some features that (in my opinion) makes it better than spring config server.
Some of these features are

The command line tool
User interface.
Access control and per-repository permission. (This part is achieved in spring config server via the Vault tool)
high-availability.

Consul

Consul is a big tool provided by HashiCorp. It is known as a service discovery tool. It is much more comparable to Eureka than to config server tools but it also provides a key/value store which can be used as an external configuration server.
Consul allows the users to store indexed objects (configuration objects) and it also replicate the data across multiple server which provide a high availability feature.

The key/value store in Consul is very simple. It is not intended to be used as a replacement to key/value stores like Redis.

Kubernetes ConfigMap and Secrets

Kubernetes ConfigMap is much like Consul key/value store. Pods can consume the configuration from the ConfigMap as environment variables, command line arguments, and configuration files.
The problem with config map is that it does not provide secrecy or encryption. So, if you need to store sensitive configurations, it is advised to use Kubernetes Secrets instead.

In the next parts we will get into more details about each option.

What are your recommended books to learn event-driven architecture?

FaN000s — Wed, 20 Nov 2019 11:49:47 +0000

Recently, I came across a paper published by O'Reilly titled "Software Architecture Patterns. Understanding Common Architecture Patterns and When to Use Them".

Although the paper is a little bit old (published 2015), It has a very good comparison between some software architecture patterns including n-tier, event-driven, and microservices. I highly recommend you to take a look at it.

The way the event-driven architecture is explained is very interesting. So, I wanted to learn more about it.

What are your recommended books to learn event-driven architecture?

My Top 3 books to learn Java programming for beginners

FaN000s — Sun, 10 Feb 2019 09:14:58 +0000

The Java programming language is one of the most used programming languages in the world and there are thousands of books out there to learn various topics.

Here are my top 3 books to learn java programming for beginners. Each of these books has its own style.

1- How to think like a computer scientist.

This book is actually the introduction course to computer programming at MIT. The book exists in two versions. One in python and the other in Java.

I usually recommend this book for computer science students.

2- Murach's java programming

If you want to learn how to get your first steps in the java programming with more practice than theory, this is the book you need.

All of Murach's publications follow the same pattern. The left page explains a specific point and the right page shows how to get this point done. So, if you open the book at any page you will find the theory at the left and the code at the right.

3- Introduction to java programming by Daniel Liang

I am considering this book a piece of art. It contains a massive amount of information. Its language is very simple for a non-native English speaker like me. The content of the book is well organized. The book also contains some intermediate and advanced topics.

The most thing I like about this book is its excersises. Each chapter has a set of excersises that start with simple tasks and its difficulty increase gradually.

What are the most suitable datastores for storing a huge number of articles and news?

FaN000s — Wed, 06 Feb 2019 11:43:57 +0000

I am assigned to a new big project at my current company. The project will collect a huge number of news articles from different sources.

The whole requirements still not clear but we can expect some of it. For example,

Building some dashboards to display some statistics about the collected news.
Full-text search (exact, fuzzy, and synonym)
Providing a way to other teams (specifically data analysis team) to query the data.

What would you suggest as a datastore for such a project?

I believe there is no one-size-fits-all solution to this type of project.

As a start, I am thinking in using Elassandra as it combines both Cassandra and Elasticsearch which may satisfy the first two points (Cassandra for aggregation and analytics and Elasticsearch for full-text search).

Still the third point not satisfied. The data analysis people are familiar more with SQL which will not be 100% provided by either Cassandra or Elasticsearch.

The other approach I am thinking in is to have another storage for the analysis team and the application responsible for writing the data will write it to both storages.

What do you think?

Help needed: Spring batch + scheduled task = no transaction

FaN000s — Sat, 02 Feb 2019 22:56:31 +0000

I have a simple spring boot application with a scheduled task. The scheduled task starts a spring batch job.

The scheduled task starts normally and the batch job works fine but nothing Is saved to the database.

You can find all the details in this SO question

https://stackoverflow.com/questions/54457041/spring-boot-repository-does-not-save-to-the-db-if-called-from-scheduled-job

Hope anyone can help.

Edit

I have updated the question at SO with the answer that worked for me.