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 stops immediately upon running - EOF error
  • How can I install and run Docker CE on OpenSUSE Linux?
  • how to read files from a python module inside docker
  • Where is the base docker image specified in Play Framework?
  • How to load and run a container at run time from a running pod
  • Host-only network for Docker container
  • .
    ├── 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.

  • Error running docker and nodemcu-build in linux (debian)
  • How to run gerrit cookbook inside docker containers?
  • Scaling mysql in Docker
  • docker website opens after a while - ec2/virtualbox
  • Cannot connect from MySQL Workbench to dockerized MySQL server
  • Openshift doesn't copy docker container files to persistence volume
  • 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.