For all platforms

Docker v 20.10 and above (since December 14th 2020)

Use your internal IP address, or connect to the special DNS name host.docker.internal, which will resolve to the internal IP address used by the host.

This is for development purpose and does not work in a production environment outside of Docker Desktop.

Linux caveats

To enable this in Docker on Linux, add --add-host=host.docker.internal:host-gateway to your docker command to enable the feature.

To enable this in Docker Compose on Linux, add the following lines to the container definition:

extra_hosts:
    - "host.docker.internal:host-gateway"

According to some users, the special DNS name only works within the Docker's default bridge network, not within custom networks.

For older macOS and Windows versions of Docker

Docker v 18.03 and above (since 2018-03-21)

Use your internal IP address, or connect to the special DNS name host.docker.internal which will resolve to the internal IP address used by the host.

Linux support pending Support host.docker.internal DNS name to host #264

For older macOS versions of Docker

Docker for Mac v 17.12 to v 18.02

It is the same as above, but use docker.for.mac.host.internal instead.

Docker for Mac v 17.06 to v 17.11

It is the same as above, but use docker.for.mac.localhost instead.

Docker for Mac 17.05 and below

To access the host machine from the Docker container, you must attach an IP address alias to your network interface. You can bind whichever IP address you want; just make sure you're not using it to anything else.

sudo ifconfig lo0 alias 123.123.123.123/24

Then make sure that you server is listening to the IP address mentioned above or 0.0.0.0. If it's listening on localhost 127.0.0.1, it will not accept the connection.

Then just point your Docker container to this IP address, and you can access the host machine!

To test, you can run something like curl -X GET 123.123.123.123:3000 inside the container.

The alias will reset on every reboot so create a start-up script if necessary.

The solution and more documentation is on here: Explore networking features on Docker Desktop

Use

host.docker.internal

instead of

localhost

I doing a hack similar to the previous posts of getting the local IP address to map to a alias name (DNS) in the container. The major problem is to get it dynamically with a simple script that works both for the Linux and OS X the host IP address. I did this script that works in both environments (even in Linux distribution with "$LANG" != "en_*" configured):

ifconfig | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" | grep -v 127.0.0.1 | awk '{ print $2 }' | cut -f2 -d: | head -n1

So, using Docker Compose, the full configuration will be:

Startup script (docker-run.sh):

export DOCKERHOST=$(ifconfig | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" | grep -v 127.0.0.1 | awk '{ print $2 }' | cut -f2 -d: | head -n1)
docker-compose -f docker-compose.yml up

docker-compose.yml:

myapp:
  build: .
  ports:
    - "80:80"
  extra_hosts:
    - "dockerhost:$DOCKERHOST"

Then change http://localhost to http://dockerhost in your code.

For a more advanced guide of how to customize the DOCKERHOST script, take a look at this post with a explanation of how it works.

Solution for Linux (kernel >=3.6).

Ok, your localhost server has a default Docker interface docker0 with IP address 172.17.0.1. Your container started with default network settings --net="bridge".

1. Enable route_localnet for the docker0 interface:

   sysctl -w net.ipv4.conf.docker0.route_localnet=1
   

2. Add these rules to iptables:

   iptables -t nat -I PREROUTING -i docker0 -d 172.17.0.1 -p tcp --dport 3306 -j DNAT --to 127.0.0.1:3306
   iptables -t filter -I INPUT -i docker0 -d 127.0.0.1 -p tcp --dport 3306 -j ACCEPT
   

3. Create MySQL user with access from '%' that means - from anyone, excluding localhost:

   CREATE USER 'user'@'%' IDENTIFIED BY 'password';
   

4. Change in your script the mysql-server address to 172.17.0.1.

From the kernel documentation:

route_localnet - BOOLEAN: Do not consider loopback addresses as martian source or destination while routing. This enables the use of 127/8 for local routing purposes (default FALSE).

This worked for me on an nginx/PHP-FPM stack without touching any code or networking where the application's just expecting to be able to connect to localhost.

Mount mysqld.sock from the host to inside the container.

Find the location of the mysql.sock file on the host running MySQL: netstat -ln | awk '/mysql(.*)?\.sock/ { print $9 }'

Mount that file to where it's expected in the Docker container: docker run -v /hostpath/to/mysqld.sock:/containerpath/to/mysqld.sock

Possible locations of mysqld.sock:

/tmp/mysqld.sock
/var/run/mysqld/mysqld.sock
/var/lib/mysql/mysql.sock
/Applications/MAMP/tmp/mysql/mysql.sock # If running via MAMP

Until host.docker.internal is working for every platform, you can use my container acting as a NAT gateway without any manual setup:

https://github.com/qoomon/docker-host

The simplest solution for Mac OS X

Just use the IP address of your Mac. On the Mac, run this to get the IP address and use it from within the container:

ifconfig | grep 'inet 192'| awk '{ print $2}'

As long as the server running locally on your Mac or in another Docker container is listening to 0.0.0.0, the Docker container will be able to reach out at that address.

If you just want to access another Docker container that is listening on 0.0.0.0, you can use 172.17.0.1.

Several solutions come to mind:

1. Move your dependencies into containers first
2. Make your other services externally accessible and connect to them with that external IP address
3. Run your containers without network isolation
4. Avoid connecting over the network. Use a socket that is mounted as a volume instead

The reason this doesn't work out of the box is that containers run with their own network namespace by default. That means localhost (or 127.0.0.1 pointing to the loopback interface) is unique per container. Connecting to this will connect to the container itself, and not services running outside of docker or inside of a different Docker container.

Option 1: If your dependency can be moved into a container, I would do this first. It makes your application stack portable as others try to run your container on their own environment. And you can still publish the port on your host where other services that have not been migrated can still reach it. You can even publish the port to the localhost interface on your Docker host to avoid it being externally accessible with a syntax like: -p 127.0.0.1:3306:3306 for the published port.

Option 2: There are a variety of ways to detect the host IP address from inside of the container, but each have a limited number of scenarios where they work (e.g., requiring Docker for Mac). The most portable option is to inject your host IP address into the container with something like an environment variable or configuration file, e.g.:

docker run --rm -e "HOST_IP=$(ip route get 1 | sed -n 's/^.*src \([0-9.]*\) .*$/\1/p')" ...

This does require that your service is listening on that external interface, which could be a security concern. For other methods to get the host IP address from inside of the container, see this post.

Slightly less portable is to use host.docker.internal. This works in current versions of Docker for Windows and Docker for Mac. And in 20.10, the capability has been added to Docker for Linux when you pass a special host entry with:

docker run --add-host host.docker.internal:host-gateway ...

The host-gateway is a special value added in Docker 20.10 that automatically expands to a host IP address. For more details see this PR.

Option 3: Running without network isolation, i.e., running with --net host, means your application is running on the host network namespace. This is less isolation for the container, and it means you cannot access other containers over a shared Docker network with DNS (instead, you need to use published ports to access other containerized applications). But for applications that need to access other services on the host that are only listening on 127.0.0.1 on the host, this can be the easiest option.

Option 4: Various services also allow access over a filesystem based socket. This socket can be mounted into the container as a bind mounted volume, allowing you to access the host service without going over the network. For access to the Docker engine, you often see examples of mounting /var/run/docker.sock into the container (giving that container root access to the host). With MySQL, you can try something like -v /var/run/mysqld/mysqld.sock:/var/run/mysqld/mysql.sock and then connect to localhost which mysql converts to using the socket.

It is very simple and quick. Check your host IP address with ifconfig (Linux) or ipconfig (Windows), and then create a docker-compose.yml file:

version: '3' # Specify docker-compose version
services:
  nginx:
    build: ./ # Specify the directory of the Dockerfile
    ports:
      - "8080:80" # Specify port mapping
    extra_hosts:
      - "dockerhost:<yourIP>"

This way, your container will be able to access your host. When accessing your database, remember to use the name you specified before, in this case dockerhost and the port of your host in which the database is running.

Solution for Windows 10

Docker Community Edition 17.06.0-ce-win18 2017-06-28 (stable)

You can use the DNS name of the host docker.for.win.localhost, to resolve to the internal IP address. (Warning: Some sources mentioned windows, but it should be win)

Overview

I needed to do something similar, that is, connect from my Docker container to my localhost, which was running the Azure Storage Emulator and CosmosDB Emulator.

The Azure Storage Emulator by default listens on 127.0.0.1. While you can change the IP address it’s bound to, I was looking for a solution that would work with default settings.

This also works for connecting from my Docker container to SQL Server and IIS, both running locally on my host with default port settings.

For Windows,

I have changed the database URL in a Spring configuration:

spring.datasource.url=jdbc:postgresql://host.docker.internal:5432/apidb

Then build the image and run. It worked for me.

For Linux, where you cannot change the interface the localhost service binds to

There are two problems we need to solve

1. Getting the IP address of the host
2. Making our localhost service available to Docker

The first problem can be solved using qoomon's docker-host image, as given by other answers.

You will need to add this container to the same bridge network as your other container so that you can access it. Open a terminal inside your container and ensure that you can ping dockerhost.

bash-5.0# ping dockerhost

Output:

PING dockerhost (172.20.0.2): 56 data bytes
64 bytes from 172.20.0.2: seq=0 ttl=64 time=0.523 ms

Now, the harder problem, making the service accessible to docker.

We can use telnet to check if we can access a port on the host (you may need to install this).

The problem is that our container will only be able to access services that bind to all interfaces, such as SSH:

bash-5.0# telnet dockerhost 22

Output:

SSH-2.0-OpenSSH_7.6p1 Ubuntu-4ubuntu0.3

But services bound only to localhost will be inaccessible:

bash-5.0# telnet dockerhost 1025

Output:

telnet: can't connect to remote host (172.20.0.2): Connection refused

The proper solution here would be to bind the service to Docker's bridge network. However, this answer assumes that it is not possible for you to change this. So we will instead use iptables.

First, we need to find the name of the bridge network that Docker is using with ifconfig. If you are using an unnamed bridge, this will just be docker0. However, if you are using a named network, you will have a bridge starting with br- that Docker will be using instead. Mine is br-5cd80298d6f4.

Once we have the name of this bridge, we need to allow routing from this bridge to localhost. This is disabled by default for security reasons:

sysctl -w net.ipv4.conf.<bridge_name>.route_localnet=1

Now to set up our iptables rule. Since our container can only access ports on the Docker bridge network, we are going to pretend that our service is actually bound to a port on this network.

To do this, we will forward all requests to <docker_bridge>:port to localhost:port

iptables -t nat -A PREROUTING -p tcp -i <docker_bridge_name> --dport <service_port> -j DNAT --to-destination 127.0.0.1:<service_port>

For example, for my service on port 1025

iptables -t nat -A PREROUTING -p tcp -i br-5cd80298d6f4 --dport 1025 -j DNAT --to-destination 127.0.0.1:1025

You should now be able to access your service from the container:

bash-5.0# telnet dockerhost 1025

Output:

220 127.0.0.1 ESMTP Service Ready

None of the answers worked for me when using Docker Toolbox on Windows 10 Home, but 10.0.2.2 did, since it uses VirtualBox which exposes the host to the VM on this address.

This is not an answer to the actual question. This is how I solved a similar problem. The solution comes totally from: Define Docker Container Networking so Containers can Communicate. Thanks to Nic Raboy

Leaving this here for others who might want to do REST calls between one container and another. Answers the question: what to use in place of localhost in a docker environment?

Get how your network looks like docker network ls

Create a new network docker network create -d my-net

Start the first container docker run -d -p 5000:5000 --network="my-net" --name "first_container" <MyImage1:v0.1>

Check out network settings for first container docker inspect first_container. "Networks": should have 'my-net'

Start the second container docker run -d -p 6000:6000 --network="my-net" --name "second_container" <MyImage2:v0.1>

Check out network settings for second container docker inspect second_container. "Networks": should have 'my-net'

ssh into your second container docker exec -it second_container sh or docker exec -it second_container bash.

Inside of the second container, you can ping the first container by ping first_container. Also, your code calls such as http://localhost:5000 can be replaced by http://first_container:5000

If you're running with --net=host, localhost should work fine. If you're using default networking, use the static IP address 172.17.0.1.

See this: What is the Linux equivalent of "host.docker.internal"?

For those on Windows, assuming you're using the bridge network driver, you'll want to specifically bind MySQL to the IP address of the Hyper-V network interface.

This is done via the configuration file under the normally hidden C:\ProgramData\MySQL folder.

Binding to 0.0.0.0 will not work. The address needed is shown in the Docker configuration as well, and in my case was 10.0.75.1.

First see this answer for the options that you have to fix this problem. But if you use docker-compose you can add network_mode: host to your service and then use 127.0.0.1 to connect to the local host. This is just one of the options described in the answer above. Below you can find how I modified docker-compose.yml from https://github.com/geerlingguy/php-apache-container.git:

 ---
 version: "3"
 services:
   php-apache:
+    network_mode: host
     image: geerlingguy/php-apache:latest
     container_name: php-apache
...

+ indicates the line I added.

[Additional info] This has also worked in version 2.2. and "host" or just 'host' are both worked in docker-compose.

 ---
 version: "2.2"

 services:
   php-apache:
+    network_mode: "host"
        or
+    network_mode: host
...

I ended up prototyping out the concept on GitHub. Check out System in a Box.

First, my answer is geared towards two groups of people: those who use a Mac, and those who use Linux.

The host network mode doesn't work on a Mac. You have to use an IP alias, see: From inside of a Docker container, how do I connect to the localhost of the machine?

What is a host network mode? See: Running containers

Secondly, for those of you who are using Linux (my direct experience was with Ubuntu 14.04 LTS (Trusty Tahr), and I'm upgrading to Ubuntu 16.04 LTS (Xenial Xerus) in production soon), yes, you can make the service running inside a Docker container connect to localhost services running on the Docker host (for example, your laptop).

How?

The key is when you run the Docker container, you have to run it with the host mode. The command looks like this:

docker run --network="host" -id <Docker image ID>

When you do an ifconfig (you will need to apt-get install net-tools your container for ifconfig to be callable) inside your container, you will see that the network interfaces are the same as the one on Docker host (for example, your laptop).

It's important to note that I'm a Mac user, but I run Ubuntu under Parallels, so using a Mac is not a disadvantage. ;-)

And this is how you connect an NGINX container to the MySQL running on a localhost.

Try this:

version: '3.5'
services:
  yourservice-here:
    container_name: container_name
    ports:
      - "4000:4000"
    extra_hosts: # <---- here
      - localhost:192.168.1.202
      - or-vitualhost.local:192.168.1.202

To get 192.168.1.202, uses ifconfig.

This worked for me.

I disagree with the answer from Thomasleveil.

Making MySQL bind to 172.17.42.1 will prevent other programs using the database on the host to reach it. This will only work if all your database users are dockerized.

Making MySQL bind to 0.0.0.0 will open the database to the outside world, which is not only a very bad thing to do, but also contrary to what the original question author wants to do. He explicitly says "The MySQL is running on localhost and not exposing a port to the outside world, so it's bound on localhost"

To answer the comment from ivant,

"Why not bind MySQL to docker0 as well?"

This is not possible. The MySQL/MariaDB documentation explicitly says it is not possible to bind to several interfaces. You can only bind to 0, 1, or all interfaces.

As a conclusion, I have not found any way to reach the (localhost only) database on the host from a docker container. That definitely seems like a very very common pattern, but I don't know how to do it.

In the seven years the question was asked, it is either Docker has changed, or no one tried this way. So I will include my own answer.

I have found all answers use complex methods. Today, I have needed this and found two very simple ways:

• use ipconfig or ifconfig on your host and make note of all IP addresses. At least two of them can be used by the container.

  • I have a fixed local network address on Wi-Fi LAN Adapter: 192.168.1.101. This could be 10.0.1.101. The result will change, depending on your router
  • I use WSL on Windows, and it has its own vEthernet address: 172.19.192.1

• use host.docker.internal. Most answers have this or another form of it depending on the OS. The name suggests it is now globally used by Docker.

A third option is to use WAN address of the machine, or in other words, the IP address given by the service provider. However, this may not work if the IP address is not static, and requires routing and firewall settings.

You need to know the gateway! My solution with a local server was to expose it under 0.0.0.0:8000, and then run Docker with subnet and run container like:

docker network create --subnet=172.35.0.0/16 --gateway 172.35.0.1 SUBNET35
docker run -d -p 4444:4444 --net SUBNET35 <container-you-want-run-place-here>

So, now you can access your loopback through http://172.35.0.1:8000.

Here is my solution; it works for my case

• set the local MySQL server to public access by comment

  #bind-address   = 127.0.0.1
  

  in file /etc/mysql/mysql.conf.d

• restart the MySQL server

  sudo /etc/init.d/mysql restart
  

• run the following command to open user root access any host

  mysql -uroot -proot
  GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH
  GRANT OPTION;
  FLUSH PRIVILEGES;
  

• create the sh script: run_docker.sh

  #!bin/bash
  
  HOSTIP=`ip -4 addr show scope global dev eth0 | grep inet | awk '{print \$2}' | cut -d / -f 1`
  
  
    docker run -it -d --name web-app \
                --add-host=local:${HOSTIP} \
                -p 8080:8080 \
                -e DATABASE_HOST=${HOSTIP} \
                -e DATABASE_PORT=3306 \
                -e DATABASE_NAME=demo \
                -e DATABASE_USER=root \
                -e DATABASE_PASSWORD=root \
                sopheamak/springboot_docker_mysql
  

• run with docker-composer

  version: '2.1'
  
  services:
    tomcatwar:
       extra_hosts:
          - "local:10.1.2.232"
       image: sopheamak/springboot_docker_mysql
       ports:
           - 8080:8080
       environment:
              - DATABASE_HOST=local
              - DATABASE_USER=root
              - DATABASE_PASSWORD=root
              - DATABASE_NAME=demo
              - DATABASE_PORT=3306
  

Connect to the gateway address.

docker network inspect bridge | grep Gateway
                    "Gateway": "172.17.0.1"

Make sure the process on the host is listening on this interface or on all interfaces and is started after Docker. If using systemd, you can add the below to make sure it is started after Docker.

[Unit]
After=docker.service

Example

python -m http.server &> /dev/null &

Output:

[1] 149976

And:

docker run --rm python python -c  "from urllib.request import urlopen;print(b'Directory listing for' in urlopen('http://172.17.0.1:8000').read())"

Output:

True

You can simply do ifconfig on the host machine to check your host IP address, and then connect to the IP address from within your container. It works perfectly for me.

On Linux, if you can ping the host.docker.internal from inside the container, but you can not reach the ports that are opened on your localhost, please make sure you have Docker installed not in rootless mode. If it is in rootless mode it is limited. Quote from documentation:

IPAddress shown in docker inspect is namespaced inside RootlessKit's network namespace. This means the IP address is not reachable from the host without nsenter-ing into the network namespace.

Host network (docker run --net=host) is also namespaced inside RootlessKit.

You can get the host IP address using an Alpine image

docker run --rm alpine ip route | awk 'NR==1 {print $3}'

This would be more consistent as you're always using Alpine to run the command.

Similar to Mariano's answer, you can use the same command to set an environment variable:

DOCKER_HOST=$(docker run --rm alpine ip route | awk 'NR==1 {print $3}') docker-compose up

Unfortunately, currently, Windows (at least docker desktop) is not supporting --net=host

Quoted from: https://docs.docker.com/network/network-tutorial-host/#prerequisites

The host networking driver only works on Linux hosts, and is not supported on Docker for Mac, Docker for Windows, or Docker EE for Windows Server.

You can try to use https://docs.docker.com/toolbox/

An additional point might be useful, especially for NGINX server configuration within a docker container. So, if your host service is supposed to read a client's url for different purposes, there is a possibility to define it, just slightly modifying the approach mentioned before in the answers:

--add-host brand-A-client.local:host-gateway

or in a docker-compose.yml

extra_hosts:
- brand-B-client.local:host-gateway

And refer to them respectively within containers. Applicable for Docker Windows/Macos/Linux.