How to get a Docker container's IP address from the host
DockerIp AddressDocker Problem Overview
Is there a command I can run to get the container's IP address right from the host after a new container is created?
Basically, once Docker creates the container, I want to roll my own code deployment and container configuration scripts.
Docker Solutions
Solution 1 - Docker
The --format
option of inspect
comes to the rescue.
Modern Docker client syntax is:
docker inspect -f '{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' container_name_or_id
Old Docker client syntax is:
docker inspect --format '{{ .NetworkSettings.IPAddress }}' container_name_or_id
These commands will return the Docker container's IP address.
As mentioned in the comments: if you are on Windows, use double quotes "
instead of single quotes '
around the curly braces.
Solution 2 - Docker
You can use docker inspect <container id>
.
For example:
CID=$(docker run -d -p 4321 base nc -lk 4321);
docker inspect $CID
Solution 3 - Docker
First get the container ID:
docker ps
(First column is for container ID)
Use the container ID to run:
docker inspect <container ID>
At the bottom, under NetworkSettings, you can find IPAddress
Or just do for UNIX based:
docker inspect <container id> | grep "IPAddress"
And for Windows CMD:
docker inspect <container id> | findstr "IPAddress"
Solution 4 - Docker
docker inspect CONTAINER_ID | grep "IPAddress"
You can add -i
to grep for ignoring the case then even the following will work:
docker inspect CONTAINER_ID | grep -i "IPaDDreSS"
Solution 5 - Docker
To get all container names and their IP addresses in just one single command.
docker inspect -f '{{.Name}} - {{.NetworkSettings.IPAddress }}' $(docker ps -aq)
If you are using docker-compose
the command will be this:
docker inspect -f '{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -aq)
The output will be:
/containerA - 172.17.0.4
/containerB - 172.17.0.3
/containerC - 172.17.0.2
Solution 6 - Docker
Add this shell script in your ~/.bashrc
or relevant file:
docker-ip() {
docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$@"
}
Then, to get an IP address of a container, simply do this:
docker-ip YOUR_CONTAINER_ID
For the new version of the Docker, please use the following:
docker-ip() {
docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$@"
}
Solution 7 - Docker
In Docker 1.3+, you can also check it using:
Enter the running Docker (Linux):
docker exec [container-id or container-name] cat /etc/hosts
172.17.0.26 d8bc98fa4088
127.0.0.1 localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.17 mysql
For windows:
docker exec [container-id or container-name] ipconfig
Solution 8 - Docker
Show all container's IP addresses:
docker inspect --format='{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -aq)
Solution 9 - Docker
As of Docker version 1.10.3, build 20f81dd
Unless you told Docker otherwise, Docker always launches your containers in the bridge network. So you can try this command below:
docker network inspect bridge
Which should then return a Containers section which will display the IP address for that running container.
[
{
"Name": "bridge",
"Id": "40561e7d29a08b2eb81fe7b02736f44da6c0daae54ca3486f75bfa81c83507a0",
"Scope": "local",
"Driver": "bridge",
"IPAM": {
"Driver": "default",
"Options": null,
"Config": [
{
"Subnet": "172.17.0.0/16"
}
]
},
"Containers": {
"025d191991083e21761eb5a56729f61d7c5612a520269e548d0136e084ecd32a": {
"Name": "drunk_leavitt",
"EndpointID": "9f6f630a1743bd9184f30b37795590f13d87299fe39c8969294c8a353a8c97b3",
"IPv4Address": "172.17.0.2/16",
"IPv6Address": ""
}
},
"Options": {
"com.docker.network.bridge.default_bridge": "true",
"com.docker.network.bridge.enable_icc": "true",
"com.docker.network.bridge.enable_ip_masquerade": "true",
"com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
"com.docker.network.bridge.name": "docker0",
"com.docker.network.driver.mtu": "1500"
}
}
]
Solution 10 - Docker
Execute:
docker ps -a
This will display active docker images:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3b733ae18c1c parzee/database "/usr/lib/postgresql/" 6 minutes ago Up 6 minutes 5432/tcp serene_babbage
Use the CONTAINER ID value:
docker inspect <CONTAINER ID> | grep -w "IPAddress" | awk '{ print $2 }' | head -n 1 | cut -d "," -f1
"172.17.0.2"
Solution 11 - Docker
My answer:
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}} %tab% {{.Name}}' $(docker ps -aq
) | sed 's#%tab%#\t#g' | sed 's#/##g' | sort -t . -k 1,1n -k 2,2n -k 3,3n -k 4,4n
Also as a bash alias:
docker-ips() { docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}} %tab% {{.Name}}' $(docker ps -aq) | sed 's#%tab%#\t#g' | sed 's#/##g' | sort -t . -k 1,1n -k 2,2n -k 3,3n -k 4,4n }
Output is sorted by IP address, and tab delimited:
# docker-ips
172.18.0.2 memcached
172.18.0.3 nginx
172.18.0.4 fpm-backup
172.18.0.5 dns
172.18.0.6 fpm-beta
172.18.0.7 exim
172.18.0.8 fpm-delta
172.18.0.9 mariadb
172.18.0.10 fpm-alpha
172.19.0.2 nextcloud-redis
172.19.0.3 nextcloud-db
172.19.0.4 nextcloud
Solution 12 - Docker
Based on some of the answers I loved, I decided to merge them to a function to get all the IP addresses and another for an specific container. They are now in my .bashrc
file.
docker-ips() {
docker inspect --format='{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -aq)
}
docker-ip() {
docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$@"
}
The first command gives the IP address of all the containers and the second a specific container's IP address.
docker-ips
docker-ip YOUR_CONTAINER_ID
Solution 13 - Docker
Here's a quick working answer:
Get your container name or ID:
docker container ls
Then get the IP:
docker inspect <container_ID Or container_name> |grep 'IPAddress'
Get the port:
docker inspect <container_ID Or container_name> |grep 'Port'
Solution 14 - Docker
I wrote the following Bash script to get a table of IP addresses from all containers running under docker-compose
.
function docker_container_names() {
docker ps -a --format "{{.Names}}" | xargs
}
# Get the IP address of a particular container
dip() {
local network
network='YOUR-NETWORK-HERE'
docker inspect --format "{{ .NetworkSettings.Networks.$network.IPAddress }}" "$@"
}
dipall() {
for container_name in $(docker_container_names);
do
local container_ip=$(dip $container_name)
if [[ -n "$container_ip" ]]; then
echo $(dip $container_name) " $container_name"
fi
done | sort -t . -k 3,3n -k 4,4n
}
You should change the variable network to your own network name.
Solution 15 - Docker
Docker is written in Go and it uses Go syntax for query purposes too.
To inspect the IP address of a particular container, you need to run the command (-f
for "format"):
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' container_id_or_name
For the container ID or name, you can run the command
docker container ls
which will list every running container.
Solution 16 - Docker
Reference containers by name:
docker run ... --name pg-master
Then grab the IP address address by name:
MASTER_HOST=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' pg-master)
Solution 17 - Docker
Here's is a solution that I developed today in Python, using the docker inspect container
JSON output as the data source.
I have a lot of containers and infrastructures that I have to inspect, and I need to obtain basic network information from any container, in a fast and pretty manner. That's why I made this script.
IMPORTANT: Since the version 1.9, Docker allows you to create multiple networks and attach them to the containers.
#!/usr/bin/python
import json
import subprocess
import sys
try:
CONTAINER = sys.argv[1]
except Exception as e:
print "\n\tSpecify the container name, please."
print "\t\tEx.: script.py my_container\n"
sys.exit(1)
# Inspecting container via Subprocess
proc = subprocess.Popen(["docker","inspect",CONTAINER],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
out = proc.stdout.read()
json_data = json.loads(out)[0]
net_dict = {}
for network in json_data["NetworkSettings"]["Networks"].keys():
net_dict['mac_addr'] = json_data["NetworkSettings"]["Networks"][network]["MacAddress"]
net_dict['ipv4_addr'] = json_data["NetworkSettings"]["Networks"][network]["IPAddress"]
net_dict['ipv4_net'] = json_data["NetworkSettings"]["Networks"][network]["IPPrefixLen"]
net_dict['ipv4_gtw'] = json_data["NetworkSettings"]["Networks"][network]["Gateway"]
net_dict['ipv6_addr'] = json_data["NetworkSettings"]["Networks"][network]["GlobalIPv6Address"]
net_dict['ipv6_net'] = json_data["NetworkSettings"]["Networks"][network]["GlobalIPv6PrefixLen"]
net_dict['ipv6_gtw'] = json_data["NetworkSettings"]["Networks"][network]["IPv6Gateway"]
for item in net_dict:
if net_dict[item] == "" or net_dict[item] == 0:
net_dict[item] = "null"
print "\n[%s]" % network
print "\n{}{:>13} {:>14}".format(net_dict['mac_addr'],"IP/NETWORK","GATEWAY")
print "--------------------------------------------"
print "IPv4 settings:{:>16}/{:<5} {}".format(net_dict['ipv4_addr'],net_dict['ipv4_net'],net_dict['ipv4_gtw'])
print "IPv6 settings:{:>16}/{:<5} {}".format(net_dict['ipv6_addr'],net_dict['ipv6_net'],net_dict['ipv6_gtw'])
The output is:
$ python docker_netinfo.py debian1
[frontend]
02:42:ac:12:00:02 IP/NETWORK GATEWAY
--------------------------------------------
IPv4 settings: 172.18.0.2/16 172.18.0.1
IPv6 settings: null/null null
[backend]
02:42:ac:13:00:02 IP/NETWORK GATEWAY
--------------------------------------------
IPv4 settings: 172.19.0.2/16 172.19.0.1
IPv6 settings: null/null null
Solution 18 - Docker
I use this simple way
docker exec -it <container id or name> hostname -i
e.g
ubuntu@myhost:~$ docker exec -it 3d618ac670fe hostname -i
10.0.1.5
Solution 19 - Docker
To extend ko-dos' answer, here's an alias to list all container names and their IP addresses:
alias docker-ips='docker ps | tail -n +2 | while read -a a; do name=${a[$((${#a[@]}-1))]}; echo -ne "$name\t"; docker inspect $name | grep IPAddress | cut -d \" -f 4; done'
Solution 20 - Docker
Combining previous answers with finding the container ID based on the Docker image name:
docker inspect --format '{{ .NetworkSettings.IPAddress }}' `docker ps | grep $IMAGE_NAME | sed 's/\|/ /' | awk '{print $1}'`
Solution 21 - Docker
NOTE!!! for Docker Compose Usage:
Since Docker Compose creates an isolated network for each cluster, the methods below do not work with docker-compose
.
The most elegant and easy way is defining a shell function, currently the most-voted answer @WouterD's:
dockip() {
docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$@"
}
Docker can write container IDs to a file like Linux programs:
Running with --cidfile=filename
, Docker dumps the ID of the container to "filename".
See "Docker runs PID equivalent Section" for more information.
--cidfile="app.cid": Write the container ID to the file
Using a PID file:
-
Running container with
--cidfile
parameter, theapp.cid
file content is like:a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
-
You can use file content to inspect Docker containers:
blog-v4 git:(develop) ✗ docker inspect `cat app.cid`
-
You can extract the container IP using an inline Python script:
$ docker inspect `cat app.cid` | python -c "import json;import sys;\ sys.stdout.write(json.load(sys.stdin)[0]['NetworkSettings']['IPAddress'])" 172.17.0.2
Here's a more human friendly form:
#!/usr/bin/env python
# Coding: utf-8
# Save this file like get-docker-ip.py in a folder that in $PATH
# Run it with
# $ docker inspect <CONTAINER ID> | get-docker-ip.py
import json
import sys
sys.stdout.write(json.load(sys.stdin)[0]['NetworkSettings']['IPAddress'])
See "10 alternatives of getting the Docker container IP addresses" for more information.
Solution 22 - Docker
docker inspect --format '{{ .NetworkSettings.IPAddress }}' <containername or containerID here>
The above works if the container is deployed to the default bridge network.
However, if using a custom bridge network or a overlay network, I found the below to work better:
docker exec <containername or containerID here> /sbin/ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'
Solution 23 - Docker
Just for completeness:
I really like the --format
option, but at first I wasn't aware of it so I used a simple Python one-liner to get the same result:
docker inspect <CONTAINER> |python -c 'import json,sys;obj=json.load(sys.stdin);print obj[0]["NetworkSettings"]["IPAddress"]'
Solution 24 - Docker
If you installed Docker using Docker Toolbox, you can use the Kitematic application to get the container IP address:
- Select the container
- Click on Settings
- Click in Ports tab.
Solution 25 - Docker
For those who came from Google to find a solution for command execution from the terminal (not by a script), "jid", which is an interactive JSON drill-down utility with autocomplete and suggestion, lets you do the same thing with less typing.
docker inspect $CID | jid
Type Tab .Net Tab and you'll see something like:
[Filter]> .[0].NetworkSettings
{
"Bridge": "",
"EndpointID": "b69eb8bd4f11d8b172c82f21ab2e501fe532e4997fc007ed1a997750396355d5",
"Gateway": "172.17.0.1",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"HairpinMode": false,
"IPAddress": "172.17.0.2",
"IPPrefixLen": 16,
"IPv6Gateway": "",
"LinkLocalIPv6Address": "",
"LinkLocalIPv6PrefixLen": 0,
"MacAddress": "02:42:ac:11:00:02",
"Networks": {
"bridge": {
"Aliases": null,
"EndpointID": "b69eb8bd4f11d8b172c82f21ab2e501fe532e4997fc007ed1a997750396355d5",
"Gateway": "172.17.0.1",
"GlobalIPv6Address": "",
Type .IPA
Tab and you'll see something like:
[Filter]> .[0].NetworkSettings.IPAddress
"172.17.0.2"
Solution 26 - Docker
To get the IP address and host port of a container:
docker inspect containerId | awk '/IPAddress/ || /HostPort/'
Output:
"HostPort": "4200"
"HostPort": "4200"
"SecondaryIPAddresses": null,
"IPAddress": "172.17.0.2",
"IPAddress": "172.17.0.2",
Solution 27 - Docker
For windows 10:
docker inspect --format "{{ .NetworkSettings.IPAddress }}" containerId
Solution 28 - Docker
This will list down all the container IPs on the host:
sudo docker ps -aq | while read line; do sudo docker inspect -f '{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $line ; done
Solution 29 - Docker
The accepted answer does not work well with multiple networks per container:
> docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' cc54d96d63ea
172.20.0.4172.18.0.5
The next best answer is closer:
> docker inspect cc54d96d63ea | grep "IPAddress"
"SecondaryIPAddresses": null,
"IPAddress": "",
"IPAddress": "172.20.0.4",
"IPAddress": "172.18.0.5",
I like to use jq
to parse the network JSON:
> docker inspect cc54d96d63ea | jq -r 'map(.NetworkSettings.Networks) []'
{
"proxy": {
"IPAMConfig": null,
"Links": [
"server1_php_1:php",
"server1_php_1:php_1",
"server1_php_1:server1_php_1"
],
"Aliases": [
"cc54d96d63ea",
"web"
],
"NetworkID": "7779959d7383e9cef09c970c38c24a1a6ff44695178d314e3cb646bfa30d9935",
"EndpointID": "4ac2c26113bf10715048579dd77304008904186d9679cdbc8fcea65eee0bf13b",
"Gateway": "172.20.0.1",
"IPAddress": "172.20.0.4",
"IPPrefixLen": 24,
"IPv6Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"MacAddress": "02:42:ac:14:00:04",
"DriverOpts": null
},
"webservers": {
"IPAMConfig": null,
"Links": [
"server1_php_1:php",
"server1_php_1:php_1",
"server1_php_1:server1_php_1"
],
"Aliases": [
"cc54d96d63ea",
"web"
],
"NetworkID": "907a7fba8816cd0ad89b7f5603bbc91122a2dd99902b504be6af16427c11a0a6",
"EndpointID": "7febabe380d040b96b4e795417ba0954a103ac3fd37e9f6110189d9de92fbdae",
"Gateway": "172.18.0.1",
"IPAddress": "172.18.0.5",
"IPPrefixLen": 24,
"IPv6Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"MacAddress": "02:42:ac:12:00:05",
"DriverOpts": null
}
}
To list the IP addresses of every container then becomes:
for s in `docker ps -q`; do
echo `docker inspect -f "{{.Name}}" ${s}`:
docker inspect ${s} | jq -r 'map(.NetworkSettings.Networks) []' | grep "IPAddress";
done
/server1_web_1:
"IPAddress": "172.20.0.4",
"IPAddress": "172.18.0.5",
/server1_php_1:
"IPAddress": "172.20.0.3",
"IPAddress": "172.18.0.4",
/docker-gen:
"IPAddress": "172.18.0.3",
/nginx-proxy:
"IPAddress": "172.20.0.2",
"IPAddress": "172.18.0.2",
Solution 30 - Docker
Docker inspect use to print all container ips and its respective names
docker ps -q | xargs -n 1 docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}} {{ .Name }}' | sed 's/ \// /'
Solution 31 - Docker
Use:
docker inspect $CID | grep IPAddress | grep -v null| cut -d '"' -f 4 | head -1
Solution 32 - Docker
docker inspect <container id> | grep -i ip
For example:
docker inspect 2b0c4b617a8c | grep -i ip
Solution 33 - Docker
For Windows containers use
docker exec <container> ipconfig
where <container>
is the name or the id of the container.
You can use docker ps
to find the id of the container.
Solution 34 - Docker
If you forgot container ID or don't want to manipulate with shell commands, it's better to use UI like Portainer.
$ docker volume create portainer_data
$ docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer
There you can find all information about container also IP.
Solution 35 - Docker
Nobody has proposed the Docker Python API yet. Docker API solution to get IP Address is fairly simple.
*NIX based OS: docker api 3.7 (updated thanks to canadadry from the comments)
import docker
client = docker.DockerClient(base_url='unix://var/run/docker.sock')
x_container = client.containers(filters={"name":"x_container"})[0]
x_ip_addr = x_container["NetworkSettings"]["Networks"]["NETWORK_NAME"]["IPAddress"]
OS Agnostic: docker api 4.0.x (added thanks to pds from the comments)
import docker
client = docker.from_env()
container = client.containers.get(container_name)
vars( container )["attrs"]["NetworkSettings"]["Networks"]["<NETWORK_NAME>"]["IPAddress"]
Wasn't too hard to find, but is useful. additionally this can be easily modified to find all IP's assigned to a container on various networks.
Solution 36 - Docker
Inspect didn't work for me. Maybe as I was using -net host
and some namespaces.
Anyway, I found this to work nicely:
docker exec -i -t NAME /sbin/ifconfig docker0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'
Solution 37 - Docker
I had to extract docker container IP Adress by docker container name for further usage in deployment scripts. For this purpose I have written the following bash command:
docker inspect $(sudo docker ps | grep my_container_name | head -c 12) | grep -e \"IPAddress\"\:[[:space:]]\"[0-2] | grep -o '[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}'
Suppose it could be handy to place it into a bash script, which would expect my_container_name as an argument...
Solution 38 - Docker
This script will get the IPv4 address for all running containers without further processing or interpreting results. If you don't want the container name as well, you can just remove the "echo -n $NAME:" line. Great for automation or filling variables.
#!/bin/sh
for NAME in $(docker ps --format {{.Names}})
do
echo -n "$NAME:"
docker inspect $NAME | grep -i "ip.*[12]*\.[0-9]*" | \
sed -e 's/^ *//g' -e 's/[",]//g' -e 's/[a-zA-Z: ]//g'
done
you can just create an alias too if you wanted like this:
alias dockerip='for NAME in $(docker ps --format {{.Names}}); do echo -n "$NAME:"; docker inspect $NAME|grep -i "ip.*[12]*\.[0-9]*"|sed -e "s/^ *//g" -e "s/[*,]//g" -e "s/[a-zA-Z: ]//g"'
Solution 39 - Docker
I had troubles with my multi-network environment so this is a more dynamic version
Get all hostnames, networks and IPs residing in one compose file
for N in $(docker-compose ps -q) ; do echo "$(docker inspect -f '{{.Config.Hostname}}' ${N}) $(docker inspect -f '{{range $i, $value := .NetworkSettings.Networks}} [{{$i}}:{{.IPAddress}}]{{end}}' ${N})"; done
Outputs
containerA [networkA:192.168.1.4] [networkB:192.168.2.4]
containerB [networkA:192.168.1.5]
To get all running containers replace the first command
for N in $(docker-compose ps -q)
with
for N in $(docker container ls | awk 'NR>=2' | cut -c1-12 );
Get IP of 1 specific container (with multiple networks), given 1 specific network
docker inspect --format='{{range $i, $value := .NetworkSettings.Networks}}{{if eq $i "NETWORKNAME"}}{{.IPAddress}}{{end}}{{end}}' CONTAINERNAME
Outputs
192.168.1.4
Get 'Hostname IP' of all containers (with multiple networks), given 1 specific network
for N in $(docker-compose ps -q) ; do echo "$(docker inspect -f '{{.Config.Hostname}}' ${N}) $(docker inspect -f '{{range $i, $value := .NetworkSettings.Networks}}{{if eq $i "intranet"}}{{.IPAddress}}{{end}}{{end}}' ${N})"; done
Outputs
containerA 192.168.1.4
containerB 192.168.1.5
Get IP of all containers (with multiple networks), given 1 specific network
for N in $(docker-compose ps -q) ; do echo " $(docker inspect -f '{{range $i, $value := .NetworkSettings.Networks}}{{if eq $i "intranet"}}{{.IPAddress}}{{end}}{{end}}' ${N})"; done
Outputs
192.168.1.4
192.168.1.5
Solution 40 - Docker
Try in Windows PowerShell:
docker inspect -f "{{ .NetworkSettings.Networks.nat.IPAddress }}" <container id>
Solution 41 - Docker
The accepted answer covers exactly what to type fairly well, but here's a minor improvement:
docker container inspect \
--format '{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}' \
$container_id_or_name
This uses the docker container inspect
instead of the more generic docker inspect
since docker is moving to a noun+verb syntax in their commands, and removing ambiguity of what you are inspecting. I've also included a space after the IP address since containers can be on more than one docker network with more than one IP address. That could be swapped out for any other character or string that makes sense to you.
For those that want to know how they can lookup other values, I often use the following to output any docker formatted syntax into json:
docker container inspect --format '{{json .}}' $container_id_or_name | jq .
You may need to install jq
for this to work, or you can leave off the trailing command to read the json as a single long line. When viewing this output, you can see each key name and it's parents so you can create your own format strings to output anything you want. The format syntax is implemented with golang's template with some extra docker specific functions included.
> Basically, once Docker creates the container, I want to roll my own code deployment and container configuration scripts.
The main reason for my answer is this comment has a huge red flag to me. It indicates that your images do not contain everything needed to run your application, a big anti-pattern when working with containers. With a dozen clients over many years, I've yet to find a real world use case to connect directly to a container by it's internal IP address from the docker host that didn't have a better option. Instead, if there's post-startup configuration in your container that needs to run, this is often done with an entrypoint script.
There is also a red flag that you are bypassing docker's networking model. With docker networking, there are two options. First, when communicating between containers, this is done with a user created network and using docker's built-in DNS to connect to the container by name or network alias rather than by an IP address that would change when the container is recreated. And for communicating from outside of docker to the container, this is done by publishing a port from the docker host to the container, and then connecting to the host on that port rather than to the container directly. If you stick with these two options, you should be able to access your application without ever knowing its internal IP address.
Solution 42 - Docker
Along with the accepted answer if you need a specific handy alias to get a specific container ip use this alias
alias dockerip='f(){ docker inspect $1|grep -i "ipaddress.*[12]*\.[0-9]*"|sed -e "s/^ *//g" -e "s/[\",]//g" -e "s/[*,]//g" -e "s/[a-zA-Z: ]//g" | sort --unique; unset -f f; }; f'
and then you can get your container ip with
dockerip <containername>
You can also use containerid instead of containername
BTW accepted great answer doenst produce a clean output so I edited it and using like this ;
alias dockerips='for NAME in $(docker ps --format {{.Names}}); do echo -n "$NAME:"; docker inspect $NAME|grep -i "ipaddress.*[12]*\.[0-9]*"|sed -e "s/^ *//g" -e "s/[\",]//g" -e "s/[_=*,]//g" -e "s/[a-zA-Z: ]//g "| sort --unique;done'
Solution 43 - Docker
Check this script: https://github.com/jakubthedeveloper/DockerIps
It returns container names with their IP's in the following format:
abc_nginx 172.21.0.4
abc_php 172.21.0.5
abc_phpmyadmin 172.21.0.3
abc_mysql 172.21.0.2
Solution 44 - Docker
Just another classic solution:
docker ps -aq | xargs docker inspect -f '{{.Name}} - {{.NetworkSettings.IPAddress }}'
Solution 45 - Docker
Linux Container
. Method 1
docker exec postgres ifconfig
. Method 2
docker exec postgres cat /etc/hosts
. Method 3
docker exec postgres ip a
. Method 4
With Powershell
docker inspect postgres | select-string 'ipaddress'
Solution 46 - Docker
If you want to quickly see all Docker IP addresses, or without typing the instance name, you can hack the docker ps
command adding this to your ~/.bashrc
file:
function docker-ips() {
docker ps | while read line; do
if `echo $line | grep -q 'CONTAINER ID'`; then
echo -e "IP ADDRESS\t$line"
else
CID=$(echo $line | awk '{print $1}');
IP=$(docker inspect -f "{{ .NetworkSettings.IPAddress }}" $CID);
printf "${IP}\t${line}\n"
fi
done;
}
This comes from a proposal by Andrew Johnstone at the Docker GitHub: https://github.com/docker/docker/issues/8786
Solution 47 - Docker
docker inspect --format "{{ .NetworkSettings.Networks.mynetwork.IPAddress }}" <containername or containerID here>
The above is for windows containers where a network has been set up with a
docker create network mynetwork
Solution 48 - Docker
docker inspect MY_CONTAINER | jq -r '.[].NetworkSettings.Networks[].IPAddress'
plus
- elegant syntax
- flexible (once you're down with jq you can use it everywhere there's json, very useful)
- powerful
minus
- needs jq installed (e.g. apt-get install jq)
Solution 49 - Docker
this worked for me, I am running on docker-toolbox 18.09.3, at windows 10 home edition:
type command 'docker-machine ls'
λ docker-machine ls NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS default * virtualbox Running tcp://192.168.98.100:2376 v18.09.6
it would show the actual IP under the URL column. E.g. '192.168.98.100'
Solution 50 - Docker
Using Python
New API
:
import docker
client = docker.DockerClient()
container = client.containers.get("NAME")
ip_add = container.attrs['NetworkSettings']['IPAddress']
print(ip_add)
Solution 51 - Docker
There are various ways to get the IP of the container from the host
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' containerID
If in case you can't remember the above command you can always do the following
docker inspect containerID
It will Return low-level information on Docker objects after the information is returned look for "Networks"
and inside it you will find "IPAddress"
of container
Solution 52 - Docker
docker inspect <container id> | grep -i "ipaddress"
Solution 53 - Docker
for containerId in $(sudo docker ps -a | cut -f1 -d' ' | grep -v CONTAINER); do
echo " ContainerId - $containerId >> $(sudo docker inspect --format '{{ .NetworkSettings.IPAddress }}' $containerId) "
done