1618367271
In this video, you will learn about configuring the Eureka service registry for High Availability. We will create three peers for Eureka Registry and configure such a way that they can talk to each other. We will create a Eureka Client that will connect to all the peers of Service Registry.
Github Link: https://bit.ly/3mLbc3I
#spring #cloud #microservice
1594162500
A multi-cloud approach is nothing but leveraging two or more cloud platforms for meeting the various business requirements of an enterprise. The multi-cloud IT environment incorporates different clouds from multiple vendors and negates the dependence on a single public cloud service provider. Thus enterprises can choose specific services from multiple public clouds and reap the benefits of each.
Given its affordability and agility, most enterprises opt for a multi-cloud approach in cloud computing now. A 2018 survey on the public cloud services market points out that 81% of the respondents use services from two or more providers. Subsequently, the cloud computing services market has reported incredible growth in recent times. The worldwide public cloud services market is all set to reach $500 billion in the next four years, according to IDC.
By choosing multi-cloud solutions strategically, enterprises can optimize the benefits of cloud computing and aim for some key competitive advantages. They can avoid the lengthy and cumbersome processes involved in buying, installing and testing high-priced systems. The IaaS and PaaS solutions have become a windfall for the enterprise’s budget as it does not incur huge up-front capital expenditure.
However, cost optimization is still a challenge while facilitating a multi-cloud environment and a large number of enterprises end up overpaying with or without realizing it. The below-mentioned tips would help you ensure the money is spent wisely on cloud computing services.
Most organizations tend to get wrong with simple things which turn out to be the root cause for needless spending and resource wastage. The first step to cost optimization in your cloud strategy is to identify underutilized resources that you have been paying for.
Enterprises often continue to pay for resources that have been purchased earlier but are no longer useful. Identifying such unused and unattached resources and deactivating it on a regular basis brings you one step closer to cost optimization. If needed, you can deploy automated cloud management tools that are largely helpful in providing the analytics needed to optimize the cloud spending and cut costs on an ongoing basis.
Another key cost optimization strategy is to identify the idle computing instances and consolidate them into fewer instances. An idle computing instance may require a CPU utilization level of 1-5%, but you may be billed by the service provider for 100% for the same instance.
Every enterprise will have such non-production instances that constitute unnecessary storage space and lead to overpaying. Re-evaluating your resource allocations regularly and removing unnecessary storage may help you save money significantly. Resource allocation is not only a matter of CPU and memory but also it is linked to the storage, network, and various other factors.
The key to efficient cost reduction in cloud computing technology lies in proactive monitoring. A comprehensive view of the cloud usage helps enterprises to monitor and minimize unnecessary spending. You can make use of various mechanisms for monitoring computing demand.
For instance, you can use a heatmap to understand the highs and lows in computing visually. This heat map indicates the start and stop times which in turn lead to reduced costs. You can also deploy automated tools that help organizations to schedule instances to start and stop. By following a heatmap, you can understand whether it is safe to shut down servers on holidays or weekends.
#cloud computing services #all #hybrid cloud #cloud #multi-cloud strategy #cloud spend #multi-cloud spending #multi cloud adoption #why multi cloud #multi cloud trends #multi cloud companies #multi cloud research #multi cloud market
1591909200
Hi all. In this blog we will see how we can leverage spring boot and Eureka server to do a Service Registry and Discovery. In the world of microservices scalability and elasticity is mandatory. That means, we can scale our services both up and down to meet the variant load requirements. Typically, this includes creating and destroying the instances of our services.
Microservices communicate with each other through exposed endpoints/APIs. For this communication to take place, the dependent service should know the address of the supplier service so as to invoke its API through a REST call. Traditionally, we use to hardcode the addresses of the services and the dependent service would send a request using these addresses. However, with dynamic scaling of services in place it become hard to keep track of their addresses everytime a new instance was created or destroyed. To overcome this problem, we use naming servers. How we use naming servers and how they help us? We will explore that in this blog. So, let’s start.
#eureka #microservices #scala #spring boot #eureka-client/server #netflix-cloud-eureka #spring-cloud #webclient
1618367271
In this video, you will learn about configuring the Eureka service registry for High Availability. We will create three peers for Eureka Registry and configure such a way that they can talk to each other. We will create a Eureka Client that will connect to all the peers of Service Registry.
Github Link: https://bit.ly/3mLbc3I
#spring #cloud #microservice
1602810603
I posted an article in regards to a single-page application(UI), but in this post, I’m going to introduce how to build microservice architecture for the J2EE application with Spring framework and open-source SSO framework Keycloak. This post will cover the following aspects:
The code is available in my Github and please check the docker-compose.yml at first so that you can read the rest of the post easier. One thing I need to mention here is you need to replace the IP address of the keycloak server URL with your own before running the docker containers.
version: '3.4'
2
services:
3
api-gateway:
4
build:
5
context: ./api-gateway
6
ports:
7
- "8080:8080"
8
restart: on-failure
9
environment:
10
#overriding spring application.properties
11
- eureka.client.serviceUrl.defaultZone=http://eureka-server:9091/eureka/
12
- keycloak-client.server-url=http://10.0.0.17:18080/auth ## use host name or ip of the host machine
13
depends_on:
14
- eureka-server
15
eureka-server:
16
build:
17
context: ./eureka-server
18
ports:
19
- "9091:9091"
20
restart: on-failure
21
microservice-consumer:
22
build:
23
context: ./microservice-consumer
24
ports:
25
- "9080:9080"
26
restart: on-failure
27
environment:
28
#overriding spring application.properties
29
- eureka.client.serviceUrl.defaultZone=http://eureka-server:9091/eureka/
30
- keycloak-client.server-url=http://10.0.0.17:18080/auth ## use host name or ip of the host machine
31
depends_on:
32
- eureka-server
33
microservice-producer:
34
build:
35
context: ./microservice-producer
36
ports:
37
- "9081:9081"
38
restart: on-failure
39
environment:
40
#overriding spring application.properties
41
- eureka.client.serviceUrl.defaultZone=http://eureka-server:9091/eureka/
42
- keycloak-client.server-url=http://10.0.0.17:18080/auth ## use host name or ip of the host machine
43
depends_on:
44
- eureka-server
45
keycloak:
46
image: jboss/keycloak:11.0.0
47
volumes:
48
- ./keycloak-server/realm-export.json:/tmp/keycloak/config/realm-export.json
49
environment:
50
KEYCLOAK_USER: admin
51
KEYCLOAK_PASSWORD: admin
52
KEYCLOAK_IMPORT: /tmp/keycloak/config/realm-export.json
53
DB_VENDOR: POSTGRES
54
DB_ADDR: postgres
55
DB_DATABASE: keycloak
56
DB_USER: keycloak
57
DB_SCHEMA: public
58
DB_PASSWORD: password
59
ports:
60
- "18080:18080"
61
command:
62
- "-b"
63
- "0.0.0.0"
64
- "-Djboss.socket.binding.port-offset=10000"
65
restart: on-failure
66
depends_on:
67
- postgres
68
postgres:
69
image: postgres
70
volumes:
71
- postgres_data:/var/lib/postgresql/data
72
environment:
73
POSTGRES_DB: keycloak
74
POSTGRES_USER: keycloak
75
POSTGRES_PASSWORD: password
76
volumes:
77
postgres_data:
78
name: keycloak_postgres_data
79
driver: local
#spring boot #microservice #spring cloud #keycloak #eureka server #spring cloud gateway #spring secuirty 5 #sso authentication #java microservice #jwt token
1602547021
The article demonstrates how to write a contract between the producer & the consumer and how to implements the producer & the consumer side test cases for Spring Cloud Contract through an HTTP request between two microservices.
The producer is a service that exposes an API (e.g. rest endpoint) or sends a message (e.g. Kafka Producer which publishes the message to Kafka Topic)
The consumer is a service that consumes the API that is exposed by the producer or listens to a message from the producer (e.g. Kafka Consumer which consumes the message from Kafka Topic)
The contract is an agreement between the producer and consumer how the API/message will look like.
Consumer-driven contract (CDD) is an approach where the consumer drives the changes in the API of the producer.
Consumer-driven contract testing is an approach to formalize above mentioned expectations into a contract between each consumer-provider pair. Once the contract is established between Provider and Consumer, this ensures that the contract will not break suddenly.
Spring Cloud Contract is a project of spring-cloud that helps end-users in successfully implementing the Consumer Driven Contracts (CDC) approach. The Spring Cloud Contract Verifier is used as a tool that enables the development of Consumer Driven Contracts. Spring Cloud Contract Verifier is used with Contract Definition Language (DSL) written in Groovy or YAML.
To understand the concept of the Spring Cloud Contract, I have implemented two simple microservices. The code for these applications can be found on Github account.
Request and response between the consumer and the producer
It is the first microservice responsible for creating an employee’s profile based on the given details. We are only passing the FirstName, LastName, and Identification Number (e.g. National ID) of the employee. This microservice is calling another microservice to first check, based on the Identity Number, whether the profile has already been created for the employee.
This is the second microservice service that is just checking if an employee profile already exists. If the employee profile is matching with the Identification Number provided in the database, it will return the profile else return an empty profile with the EMPLOYEE_NOT_FOUND status.
The create-employee-application microservice is having a dependency on get-employee-application microservice, so we have written a contract of get-employee-application. We are not using any database here to store or retrieve employee details so that written simple logic which will help us to fetch the existing employee profile.
We are going to understand how we have done the setup for these applications. We are going to discuss the setup in each microservice one by one.
#tutorial #microservices #spring boot #spring cloud #spring boot microservices #spring cloud contract #microservices testing