.Net Core API with Redis on Kubernetes cluster(minikube) - asp.net-core

Question

I have implemented a .Net Core API which is caching and accessing the data from Redis cache. I have created images for API and Redis and deployed both of them on 2 different pods. Currently I am using minikube as a Kubernetes cluster on my local machine.
.Net API code:
Controller method code:
[HttpGet]
public IActionResult Get()
{
var cacheKey = "weatherList";
var rng = new Random();
IEnumerable<WeatherForecast> weatherList = new List<WeatherForecast>();
var redisWeatherList = _distributedCache.Get(cacheKey);
if (redisWeatherList != null)
{
var serializedWeatherList = Encoding.UTF8.GetString(redisWeatherList);
weatherList = JsonConvert.DeserializeObject<List<WeatherForecast>>(serializedWeatherList);
return Ok(new Tuple<IEnumerable<WeatherForecast>, string>(weatherList, "Data fetched from cache"));
}
else
{
weatherList = Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
}).ToArray();
var serializedWeatherList = JsonConvert.SerializeObject(weatherList);
redisWeatherList = Encoding.UTF8.GetBytes(serializedWeatherList);
var options = new DistributedCacheEntryOptions()
.SetAbsoluteExpiration(DateTime.Now.AddSeconds(5));
_distributedCache.Set(cacheKey, redisWeatherList, options);
return Ok(new Tuple<IEnumerable<WeatherForecast>>(weatherList));
}
}
Redis cache configuration in the Startup class
services.AddStackExchangeRedisCache(options =>
{
options.Configuration = Configuration.GetSection("AppConfiguration").GetSection("RedisConfiguration").Value;
});
For deployment I have created the deployment and service yaml files for both of them. Since we have to access the API so its type is selected as LoadBalancer and Redis will be interacted by the API type is selected as default ClusterIP.
YML files:
API YML files:
apiVersion: apps/v1
kind: Deployment
metadata:
name: api-deployment
labels:
app: api-deployment
spec:
replicas: 1
selector:
matchLabels:
app: api-deployment
template:
metadata:
labels:
app: api-deployment
spec:
volumes:
- name: appsettings-volume
configMap:
name: appsettings-configmap
containers:
- name: api-deployment
image: testapiimage
imagePullPolicy: IfNotPresent
ports:
- containerPort: 80
volumeMounts:
- name: appsettings-volume
mountPath: /app/appsettings.json
subPath: appsettings.json
resources:
requests:
cpu: 100m
memory: 100Mi
limits:
cpu: 200m
memory: 200Mi
apiVersion: v1
kind: Service
metadata:
name: api-service
labels:
app: api-service
spec:
ports:
- port: 8080
targetPort: 80
type: LoadBalancer
selector:
app: api-deployment
Redis YML files:
apiVersion: apps/v1
kind: Deployment
metadata:
name: redis-deployment
labels:
app: redis-deployment
spec:
replicas: 1
selector:
matchLabels:
app: redis-deployment
template:
metadata:
labels:
app: redis-deployment
spec:
containers:
- name: redis-deployment
image: redis
ports:
- containerPort: 6379
resources:
requests:
cpu: 100m
memory: 100Mi
limits:
cpu: 200m
memory: 200Mi
apiVersion: v1
kind: Service
metadata:
name: redis-service
labels:
app: redis-service
spec:
ports:
- port: 6379
targetPort: 6379
selector:
app: redis-deployment
Now the issue and confusion is how API will know how to connect to the ClusterIP of Redis pod. In the local code it is connecting through localhost. Therefore, while API container is running it is still trying to connect to the Redis container through localhost only just like in code.
Is there any way that the API container will automatically connected to the ClusterIP of the Redis container like Environment variables but in my case I have to depend on the value of Redis host which in the container environment is the ClusterIP which is not static and cant be injected through appsettings.
Please guide me here.

Answer 1

To reach other pods in the cluster that are not exposed publicly, you can use the fully qualified domain name (FQDN) assigned by the Kubernetes internal DNS. Kubernetes internal DNS will resolve this to the necessary ClusterIP value to reach the service.
The FQDN is in the format:
<service-name>.<namespace>.svc.<cluster-domain>
The default value of the cluster-domain is cluster.local and if no namespace was provided to redis, it will be running in the default namespace.
Assuming all defaults, the FQDN of the redis service would be:
redis-service.default.svc.cluster.local.
Kubernetes will automatically resolve this to the appropriate ClusterIP address.
https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/