Question 121040 in Redis Question posted in
The official documentation can be found here.

Redis – How to define a readiness probe on a container for checking another containers health in the same pod?

I have a Deployment object with Container A and Container B in OpenShift.
The requirement here is that whenever container B exits, container A should follow or otherwise the entire pod should be replaced.

Is there any way to achieve this?

This is my YAML.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-redis-bundle
  labels:
    app: app-redis-bundle
spec:
  replicas: 1
  selector:
    matchLabels:
      app: app-redis-bundle
  template:
    metadata:
      labels:
        app: app-redis-bundle
    spec:
      containers:
        - name: cache-store-2
          image: redis
          resources:
            limits:
              cpu: 500m
              memory: 1500Mi
            requests:
              cpu: 250m
              memory: 1Gi
          ports:
            - containerPort: 6379
          livenessProbe:
            tcpSocket:
              port: 6379
        
        - name: app-server-2
          image: 'app:latest'
          resources:
            limits:
              cpu: '1'
              memory: 1Gi
            requests:
              cpu: 500m
              memory: 512Mi
          ports:
            - containerPort: 8443
          livenessProbe:
            tcpSocket:
              port: 8443
      imagePullSecrets:
        - name: mysecret
Tags:

2

Answers


  1. Chosen as BEST ANSWER
    0

    Thanks for your comments.

    The issue is resolved now.

    Allow me to elaborate it and explain the solution.

    Problem Statement

    I was needed to deploy a Pod in OpenShift with 2 containers A and B in a manner such that whenever container A terminates, container B should automatically kill itself as well.

    Initially, my approach was to run a termination script in container B from container A. However, this approach didn't help.

    Solution

    Using a liveness probe to send a TCP Socket connection from B to A on the running port did the magic and now B is terminating as soon as A exits.

    Job done.

    Below is the working yaml.

    apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
  name: live
spec:
  restartPolicy: Never
  containers:
  - name: nginx
    image: nginx:latest
    args:
    - /bin/sh
    - -c
    - touch /tmp/healthy; sleep 30; rm -f /tmp/healthy; sleep 600;
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5
      periodSeconds: 5

  - name: liveness
    image: registry.k8s.io/busybox
    ports:
    - containerPort: 80
    livenessProbe:
      tcpSocket:
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 5

  2. 0

    both containers use the same ephemeral network, which means container A can communicate with container B on "localhost:port".

    This multi-container pod is explained here in a clear way.

    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search