Docker – send http request from one container to another

I cannot send an HTTP request to backend container when I’m running app on AWS server production. However, when I’m running app locally I can make requests to backend just fine. For making requests I use fetch:

fetch('http://localhost:8000/something')

Here is how project structure looks like:

  • Docker container DHCP like bridged VirtualBox
  • CircleCI - Git could not resolve host when cloning repository
  • Bitbucket Pipelines - access to another container
  • How to overwrite default command when running docker image
  • Accelerate build of application in Docker container via CircleCI
  • RabbitMQ Cluster in Docker Container among different hosts
  • .
    ├── docker-compose.yml
    |
    ├── backend
    │   ├── Dockerfile
    │   └── server.js
    |
    └── frontend
        ├── Dockerfile
        ├── package.json
        ├── public
        │   └── index.html
        └── src
           ├── components
           ├── data
           ├── index.js
           ├── routes.js
           ├── static
           ├── tests
           └── views
    

    docker-compose.yml:

    version: '3'
    
    services:
      frontend:
        build:
          context: .
          dockerfile: frontend/Dockerfile
        volumes:
          - ./frontend:/frontend
        ports:
          - "80:5000"
        links:
          - backend
      backend:
        build:
          context: .
          dockerfile: backend/Dockerfile
        volumes:
          - ./backend:/backend
        ports:
          - "8000:8000"
    

    Dockerfile in frontend:

    FROM node:latest
    
    RUN mkdir -p /frontend
    
    WORKDIR /frontend
    
    ADD . /frontend
    
    VOLUME ["/frontend"]
    
    EXPOSE 5000
    
    CMD yarn && yarn build && yarn global add serve && serve -s build
    

    Dockerfile in backend:

    FROM node:latest
    
    RUN mkdir -p /backend
    
    WORKDIR /backend
    
    ADD . /backend
    
    VOLUME ["/backend"]
    
    EXPOSE 8000
    
    CMD yarn && yarn start
    

    Can someone explain me what is wrong with my config? I’m very confused, because it works without any issues locally.

  • Using Docker Environment Variable inside of Java
  • Free Docker volume drivers? [closed]
  • Pass folder between builds - GitLab CI with Docker
  • Docker client not able to connect to docker host on VM on Windows 7
  • Docker: Error while executing 'docker run hello-world' command
  • Running package manager inside the docker
  • One Solution collect form web for “Docker – send http request from one container to another”

    TLDR: Need to change the frontend code to call the current host instead of ‘localhost’

    The problem is your app is saying ‘hey localhost’ instead of ‘hey VPS ip’, when visiting from YOUR browser. You need to edit your frontend code to visit the current host you’re visiting. That’s why you’re receiving a request on YOUR localhost server.

    Instead of fetch("http:///localhost:8000/something") change it to fetch("http://"+location.host+":8000") (There are better ways, this gets it done).

    Also note docker containers are a little different in terms of networking as well. A docker container doesn’t really have a concept of ‘localhost’ the same way non docker container apps do. You have to use the VPS’s IP/Local IP when making the call from server to server. A trick I use is to use docker’s default docker0 bridge 172.17.0.1.

    I tend to use networks over ‘links’ and actually cant comment fully on it, but when containers were on the same docker network, you could access the other container by using the container’s name. This only works for server side code however, ie: node.js server -> node.js server/mongo db. Example mongodb connection would be mongodb://mongo_server:27017/mydatabase and mongo_server would resolve to the container’s IP.

    Another thing you’ll possibly encounter when attempting to use the IP is your firewall, you would have to allow that particular ip/port in through your firewall as well.

    Docker will be the best open platform for developers and sysadmins to build, ship, and run distributed applications.