Forem: Prashanta Chakraborty

Docker Port Exposing: My Real Production Mistake

Prashanta Chakraborty — Sat, 21 Feb 2026 14:22:41 +0000

I’m developing a Bangladesh-based healthcare system, Gooddoktor.
Recently, I deployed my backend in a VPS using Docker.

I don’t have hardcore DevOps knowledge. I mostly:
learn → try → break → fix.
I set up nginx for the subdomain, all is ok. So yesterday I randomly tried a port scan on my own server. And guess what? I found multiple OPEN PORTS. Even worse…

I could access my project using: http://SERVER_IP:PORT. No domain, no SSL, Nothing. Anyone on the internet could directly access my services.

My First Thought
I asked ChatGPT:

GPT gave firewall rules → I applied them → still accessible.
Then I Googled → again firewall → again same result.

So clearly, the issue was not the firewall. That means something else was exposing the port.

The Real Problem (Docker Did It)
In my docker-compose I wrote:

ports:
 - "2525:2525"

Looks normal, right? But this line is VERY dangerous in production.

What actually happens
Docker doesn’t just run inside your machine. When you map a port like this:

2525:2525

Docker tells Linux: Bind container port 2525 to ALL NETWORK INTERFACES, Meaning: 0.0.0.0:2525 And 0.0.0.0 means: Accept connections from anywhere in the world

So the firewall allowed 80 & 443 only. But Docker bypassed it by opening its own socket. That’s why I could access:

http://ip:2525
Why the Firewall Didn’t Save Me
Important lesson:

Docker publishes ports BEFORE your firewall filtering in many cases (nat table). So, UFW rules ≠ protection if Docker exposes ports publicly. That’s why even after blocking, it still worked.

The Fix (Actual Solution)
Instead of:

ports:
- "2525:2525"

I changed to:

ports:
- "127.0.0.1:2525:2525"

Now Docker binds to:

127.0.0.1:2525
Meaning:

Only accessible from inside the server. Nginx can access. The Internet cannot. And boom. IP access stopped working.

Why This Works

Network scope difference:

Binding: 0.0.0.0, Meaning: Public internet | Binding: SERVER_IP, Meaning: Public internet | Binding: 127.0.0.1, Meaning: Only local machine

So now the flow becomes:

User → Domain → Nginx → localhost:2525 → Docker → App

Instead of:

User → Directly → Backend (very bad)

What I Learned

Docker is not just a container; it’s a network gateway
Port mapping is public by default
A firewall alone cannot save a bad Docker config
Production server should NEVER expose app ports
Always expose only nginx (80/443)
Final Advice

If you’re deploying backend/services with Docker and nginx:

Never do this in production

ports:
- "3000:3000"

Always do this:

ports:
- "127.0.0.1:3000:3000"

Deployment is not coding…
Deployment is security.

And security mistakes don’t crash your app. They silently make your app public.

Using Axios Instance with Interceptors in Redux Toolkit Query (RTK Query)

Prashanta Chakraborty — Wed, 11 Oct 2023 21:18:16 +0000

In this blog post, we'll walk through the process of setting up a Redux store that integrates a custom Axios instance with request and response interceptors, in addition to Redux Toolkit Query (RTK Query). This comprehensive setup allows you to manage the state of your React application while efficiently handling API requests and responses.

Prerequisites

Before we start, make sure you have the following prerequisites in place:

A React application set up and ready to integrate Redux.
Axios installed in your project. You can install Axios via npm or yarn:

npm install axios
# or
yarn add axios

Creating a Custom Axios Instance

First, let's create a custom Axios instance with request and response interceptors. This will give you the flexibility to modify requests and responses globally:

// axiosInstance.js

import axios from 'axios';

const axiosInstance = axios.create({
  baseURL: 'https://api.example.com', // Replace with your API base URL
  headers: {
    'Content-Type': 'application/json',
    // Add any other headers or configurations you need
  },
});

// Add a request interceptor
axiosInstance.interceptors.request.use(
  (config) => {
    // You can modify the request config here, e.g., add authentication headers
    // config.headers.Authorization = `Bearer ${getToken()}`;
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

// Add a response interceptor
axiosInstance.interceptors.response.use(
  (response) => {
    // You can modify the response data here, e.g., handling pagination
    return response.data;
  },
  (error) => {
    return Promise.reject(error);
  }
);

export default axiosInstance;

In the code above:

We've created a custom Axios instance that includes both request and response interceptors, giving you full control over the communication with your API.

Setting up the Redux Store

Next, let's set up the Redux store to work in conjunction with Redux Toolkit Query. Ensure you have Redux and RTK Query installed in your project:

npm install @reduxjs/toolkit react-redux
# or
yarn add @reduxjs/toolkit react-redux

Here's how you can set up your Redux store with RTK Query:

// store.js

import { configureStore } from '@reduxjs/toolkit';
import { api } from './api'; // Import your RTK Query API

const store = configureStore({
  reducer: {
    [api.reducerPath]: api.reducer,
  },
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware().concat(api.middleware),
});

export default store;

In this store setup:

We import the api object generated by RTK Query.
The API reducer and middleware are integrated into the Redux store configuration.

Integrating RTK Query with the Custom Axios Instance

With your Redux store in place, you can integrate RTK Query with the custom Axios instance. This is the same step we covered in the previous sections.

// api.js

import { createApi } from '@reduxjs/toolkit/query'
import axiosInstance from './axios'

const axiosBaseQuery =
  ({ baseUrl } = { baseUrl: '' }) =>
  async ({ url, method, data, params, headers }) => {
    try {
      const result = await axiosInstance({
        url: baseUrl + url,
        method,
        data,
        params,
        headers,
      })
      return { data: result.data }
    } catch (axiosError) {
      const err = axiosError
      return {
        error: {
          status: err.response?.status,
          data: err.response?.data || err.message,
        },
      }
    }
  }

const api = createApi({
  baseQuery: axiosBaseQuery({
    baseUrl: 'https://example.com',
  }),
  endpoints(build) {
    return {
      query: build.query({ query: () => ({ url: '/query', method: 'get' }) }),
      mutation: build.mutation({
        query: () => ({ url: '/mutation', method: 'post' }),
      }),
    }
  },
})

In this step, we're integrating RTK Query with the custom Axios instance, as explained in previous sections.

Using the Redux Store and RTK Query

Finally, you can use the Redux store and RTK Query in your React components to manage state and make API requests:

// MyComponent.js

import React from 'react';
import { useGetResourceQuery, useCreateResourceMutation } from './api'; // Import the generated hooks

function MyComponent() {
  const { data, error, isLoading } = useGetResourceQuery(1); // Replace 1 with the resource ID you want to fetch

  const [createResource] = useCreateResourceMutation();

  // Use createResource function to create a new resource

  return (
    <div>
      {/* Render your component based on the API data and loading/error states */}
    </div>
  );
}

export default MyComponent;

By following these steps, you've set up a Redux store with a custom Axios instance that includes request and response interceptors. You've also integrated RTK Query for efficient state management and API communication in your React application. This combination offers control, flexibility, and convenience for managing your application's data.

That's it! You've now set up a Redux store with a custom Axios instance and integrated it with RTK Query to manage state and API requests in your React application. This approach allows you to have full control over the Axios instance and API interactions while leveraging the benefits of Redux and RTK Query for state management.

Follow Me on:
facebook
linkedin