How to Setup and Run Redis in Docker?

Redis is an open-source and in-memory data structure store that is widely known for its excellent performance in handling various data types such as strings, hashes, lists, sets, etc. Redis was originally developed as a caching solution, but it has evolved into a powerful tool for real-time analytics, message brokering, session management, and queuing systems.

However, deploying and managing Redis instances can be difficult, especially in environments that are concerned with scalability, consistency, and resource utilization. This is where Docker’s lightweight containerization capabilities come into the picture. When you run Redis in Docker containers, you can consistently deploy, scale, and manage Redis instances across multiple environments.

Here are the major ways to set up and run Redis inside Docker containers −

  • Pulling the Redis Docker base image from the official Docker Hub repository and customizing Redis container settings via Dockerfile.
  • Creating a Docker Compose file to define and manage Redis container configuration.
  • Utilizing Kubernetes for orchestrating Redis containers in a clustered environment.

In this chapter, let’s discuss how to setup and run Redis inside Docker containers using all these 3 approaches, in a detailed, step-by-step manner with examples and Docker commands.

How to Setup and Run Redis in Docker using Dockerfile?

Here's a step-by-step guide on how to set up and run Redis using a Dockerfile:

Step 1: Create a Dockerfile

Start by creating a `Dockerfile` in your project directory. This file will contain the instructions and commands to build the Docker image with Redis pre-installed.

# Use the official Redis image as the base image
FROM redis:latest

# Set metadata for the container
LABEL maintainer="Your Name <your@email.com>"

# Expose Redis default port
EXPOSE 6379

Explanation

  • The `FROM` instruction specifies the base image that we will use. In this case, we will use the latest version of the official Redis image from Docker Hub.
  • The `LABEL` instruction adds metadata to the image. Here, we have added the maintainer's name and email.
  • The `EXPOSE` instruction exposes Redis's default port `6379`. This allows it to accept connections from other containers or the host machine.

Step 2: Build the Docker Image

Navigate to the directory where you have created your Dockefile and run the Docker build command below to create the Docker image.

docker build -t my-redis-image .

Explanation

  • `docker build` is the command that can be used to build a Docker image.
  • `-t my-redis-image` adds a tag to the image for easy reference.
  • `.` specifies the build context. It indicates that the `Dockerfile` is located in the current directory.

Step 3: Run the Redis Container

Now that you have your Docker image built, you can run a container associated to that image using the Docker run command.

docker run --name my-redis-container -d my-redis-image

The `docker run` is the command that we have used to run a Docker container. The `--name my-redis-container` is used to assign a name to the running container for easy identification. The `-d` flag is used to run the container in detached mode, meaning it runs in the background. Then we specify the image name `my-redis-image` of the Docker image to be used for creating the container.

Step 4: Verify the Container

If you want to ensure that the Redis container is running successfully, you can use the below command to list all running containers −

docker ps

This will display information about the running Redis container, including its container ID, name, status, and ports.

Step 5: Access Redis

After verifying that the Redis container is running, you can now access it using Redis client tools like RedisInsight or connect to it from other applications and services. By default, Redis will be accessible on port `6379` that we mentioned in the Dockerfile.

How to Run Redis in Docker using Docker Compose?

Docker Compose simplifies the process of defining and managing multi-container Docker applications. Here's how to run Redis in Docker using Docker Compose −

Step 1: Create a Docker Compose File

You can start by creating a new file named `docker-compose.yml` in your project directory.

version: '3.8'
   
services:
  redis:
    image: redis:latest
    container_name: my-redis-container
    ports:
      - "6379:6379"

In this file, we have specified the `version: '3.8'` version of Docker Compose syntax being used. Then, under `services`, we have defined the Redis service: The `image: redis:latest` specifies the Redis image to be pulled and used from Docker Hub. Next, we have defined the container name using the property `container_name: my-redis-container`. Finally, the port to be exposed has been specified using `ports` which maps port `6379` on the host machine to port `6379` in the container, allowing access to Redis.

Step 2: Run Docker Compose

Next, you can run the Docker compose command to start the container which has Redis installed in it. Navigate to the directory where you have created the compose yml file and run the below command.

docker-compose up -d

Explanation

  • `docker-compose up` command is used to create and start Docker containers using the configurations defined in the `docker-compose.yml` file.
  • `-d` flag is used to run the containers in detached mode, meaning they run in the background.

Step 3: Verify and access Redis from the Container

You can list all the running containers using the below command to verify if the Redis Docker container is running or not.

docker ps

With the Redis container running, you can now access it using Redis client tools like RedisInsight or connect to it from other applications. By default, Redis is accessible on port `6379`.

Step 4: Stop and Remove Containers

You can use the Docker compose down command if you want to stop and remove the Redis container created by Docker Compose.

docker-compose down

How to run Redis in Docker Containers using Kubernetes?

Kubernetes is a popular container orchestration platform that simplifies the deployment, scaling, and management of containerized applications. Here is a step-by-step guide on how you can utilize Kubernetes to orchestrate Redis containers in a clustered environment.

Step 1: Setup Kubernetes Cluster

The first thing you need to do is set up a Kubernetes cluster. You can use managed Kubernetes services like Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS), or deploy Kubernetes locally using tools like Minikube or kind.

Step 2: Create a Redis Deployment YAML

Next, you can create a YAML file called `redis-deployment.yaml` where you can define the Redis deployment configuration.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
spec:
  replicas: 3
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
        - name: redis
          image: 'redis:latest'
          ports:
            - containerPort: 6379

In this YAML file, we have defined a Kubernetes Deployment object named `redis` with 3 replicas. Each replica will run a Redis container based on the latest Redis image from Docker Hub. The container will listen on port `6379`.

Step 3: Apply the Redis Deployment

Next, you have to apply the Redis Deployment configuration to your Kubernetes cluster.

kubectl apply -f redis-deployment.yaml

This command will help you to create the Redis Deployment and start the specified number of Redis pods (containers) as per the defined replicas.

Step 4: Expose Redis Service

Next, you can create a Kubernetes Service to expose the Redis Deployment internally within the Kubernetes cluster.

apiVersion: v1
kind: Service
metadata:
  name: redis
spec:
  selector:
    app: redis
  ports:
    - protocol: TCP
      port: 6379
      targetPort: 6379

In this YAML file, we have defined a Kubernetes Service named `redis` that selects the Redis pods based on the `app: redis` label. It then exposes port `6379` within the Kubernetes cluster.

Step 5: Apply the Redis Service

The last step is to apply the Service configuration using the following command.

kubectl apply -f redis-service.yaml

This command can be used to create a Kubernetes Service for the Redis Deployment. This will allow other pods within the cluster to access Redis using the service name `redis`.

Step 6: Access Redis

You can now access the Redis service from other pods within the Kubernetes cluster using the service name `redis` and port `6379`.

Conclusion

In conclusion, when we leverage Docker and Kubernetes for deploying and orchestrating Redis containers, it offers significant advantages in terms of simplicity, scalability, and reliability. With the help of Docker, it is very straightforward to set up Redis. Furthermore, Kubernetes provides robust container orchestration capabilities. This enables the seamless deployment and scaling of Redis clusters in a production environment.

Frequently Asked Questions

Q1. Can I persist Redis data when running it in Docker?

Yes, you can use Docker volumes to persist Redis data when running it in Docker. Data can be stored outside of the container's filesystem using Docker volumes, which guarantee that the data will not be lost in the event that the container is stopped or removed.

You can make a Docker volume and mount it to the relevant directory inside the Redis container containing the data in order to persist Redis data. In the event of a container failure or restart, this guarantees that any modifications made to the Redis data are preserved on the host system, enabling data durability and recovery.

Q2. How can I configure Redis settings when running it in Docker?

Redis can be configured using environment variables or a custom Redis configuration file when it is run in a Docker container. The Redis container can alter default parameters like the Redis port, password, and maximum memory limit when environment variables are passed to it via Docker.

Moreover, you can use a Docker volume or the `COPY` command in a Dockerfile to mount a customized Redis configuration file inside the container with the parameters you want. This lets you optimize performance and security by fine-tuning Redis configurations based on your application's needs.

Q3. Is it possible to run multiple Redis instances in Docker for different purposes?

Yes, by building distinct Docker containers for each Redis instance, it is possible to run numerous instances of Redis in Docker for various purposes. With Docker, you can operate several containers at once, each with its own separate networking, storage, and configuration settings environment.

Multiple Redis containers can be created for various uses, including caching, session management, or queuing, with unique names, ports, and configurations. You may improve resource isolation, scalability, and flexibility in managing your Redis infrastructure to match the various needs of your apps by running several Redis instances in Docker.

Advertisements