I am trying to pass an environment variable into my devcontainer that is the output of a command run on my dev machine. I have tried the following in my devcontainer.json with no luck:
"initializeCommand": "export DOCKER_HOST_IP=\"$(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)\"",
"containerEnv": {
"DOCKER_HOST_IP1": "${localEnv:DOCKER_HOST_IP}",
"DOCKER_HOST_IP2": "${containerEnv:DOCKER_HOST_IP}"
},
and
"runArgs": [
"-e DOCKER_HOST_IP=\"$(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)\"
],
(the point of the ifconfig/grep piped command is to provide me with the IP of my docker host which is running via Docker for Desktop (Mac))
Some more context
Within my devcontainer I am running some kubectl deployments (to a cluster running on Docker for Desktop) where I would like to configure a hostAlias for a pod (docs) such that that pod will direct requests to https://api.cancourier.local to the ip of the docker host (which would then hit an ingress I have configured for that CNAME).
I could just pass in the output of the ifconfig command to my kubectl command when running from within the devcontainer. The problem is that I get two different results from this depending on whether I am running it on my host (10.0.0.89) or from within the devcontainer (10.1.0.1). 10.0.0.89 in this case is the "correct" IP as if I curl this from within my devcontainer, or my deployed pod, I get the response I'd expect from my ingress.
I'm also aware that I could just use the name of my k8s service (in this case api) to communicate between pods, but this isn't ideal. As for why, I'm running a Next.js application in a pod. The Next.js app on this pod has two "contexts":
my browser - the app serves up static HTML/JS to my browser where communicating with https://api.cancourier.local works fine
on the pod itself - running some things (ie. _middleware) on the pod itself, where the pod does not currently know what https://api.cancourier.local
What I was doing to temporarily get around this was to have a separate config on the pod, one for the "browser context" and the other for things running on the pod itself. This is less than ideal as when I go to deploy this Next.js app (to Vercel) it won't be an issue (as my API will be deployed on some publicly accessible CNAME). If I can accomplish what I was trying to do above, I'd be able to avoid this.
So I didn't end up finding a way to pass the output of a command run on the host machine as an env var into my devcontainer. However I did find a way to get the "correct" docker host IP and pass this along to my pod.
In my devcontainer.json I have this:
"runArgs": [
// https://stackoverflow.com/a/43541732/3902555
"--add-host=api.cancourier.local:host-gateway",
"--add-host=cancourier.local:host-gateway"
],
which augments the devcontainer's /etc/hosts with:
192.168.65.2 api.cancourier.local
192.168.65.2 cancourier.local
then in my Makefile where I store my kubectl commands I am simply running:
deploy-the-things:
DOCKER_HOST_IP = $(shell cat /etc/hosts | grep 'api.cancourier.local' | awk '{print $$1}')
helm upgrade $(helm_release_name) $(charts_location) \
--install \
--namespace=$(local_namespace) \
--create-namespace \
-f $(charts_location)/values.yaml \
-f $(charts_location)/local.yaml \
--set cwd=$(HOST_PROJECT_PATH) \
--set dockerHostIp=$(DOCKER_HOST_IP) \
--debug \
--wait
then within my helm chart I can use the following for the pod running my Next.js app:
hostAliases:
- ip: {{ .Values.dockerHostIp }}
hostnames:
- "api.cancourier.local"
Highly recommend following this tutorial: Container environment variables
In this tutorial, 2 methods are mentioned:
Adding individual variables
Using env file
Choose which is more comfortable for you, good luck))
How do I get a list of all the containers in a user-defined docker network?
I would like to get all the commit hashes of every container for a specific user-defined docker network.
docker network inspect \
-f '{{ range $key, $value := .Containers }}{{ printf "%s\n" $key}}{{ end }}' \
<network-id>
will give a newline delimited list of the container hashes belonging to the network-id network.
You can adjust the printf format to get other syntax (comma-separated, tab-separated, container id+name, etc). For example:
$ docker network inspect \
-f '{{ range $key, $value := .Containers }}{{printf "%s: %s\n" $key .Name}}{{ end }}' \
web-ingress
0b7f82ad7535ac7c1a454aaf0a5df6b87547d3cb9d751d0e0e1b4952a849b11b: mon_grafana.1.v5i0ea6nv12k0h3eo8egglg6n
1cce723642af2ce9382c7d46cca868d4674b4645d07458eeed9e928d29a4fb1f: mon_prometheus.1.lsfdcig6uhqfbbv7n07irpj3j
1f4840710f77fa1e02bd3e95581139b9f3c13fe4c857ce6ac44bfbdae4916920: mon_alertmanager.1.kwvw7kqsfpi9qzpmqdrd85yc7
2efea443fee41fd5dbca714145ca6ff95d91be9c60a469be597aadfaca90914d: mon_unsee.1.3lg8qgnvshibklnypzt5rw95s
6fdb893488f6e56766501e763d4c60196ae12a22ee9bd204d84fe324331714e8: mon_dashboard.1.r6b6nhatwmk88y5ncgagnaxh4
lb-web-ingress: web-ingress-endpoint
You can list all networks with:
docker network ls
And inspect one network to see its hosts (containers)
docker network inspect <network-id>
Inspecting that a container, you can see which network it is connected to:
docker inspect <container-id>
More info in the docs: https://docs.docker.com/engine/userguide/networking/work-with-networks/#create-networks
Another way using pure bash and no python - easier to remember for me
docker network inspect YOUR_NETWORK_ID | grep Name | tail -n +2 | cut -d':' -f2 | tr -d ',"'
Sample output
container1
container2
A simple command to list the names of the container using a custom network is:
docker inspect network-name | grep Name
This command will list the name of the network and containers connected to it like below:
"Name": "network-name",
"Name": "Container1",
"Name": "Container2",
Solution can be simple as below as well. To list name of the container only
docker network inspect NETWORK ID | grep "Name" | awk -F":" '{print $2}' | tr -d ',"'
This is my bash command using python's json parsing
docker network inspect YOUR_NETWORK_ID \
| python -c "import sys, json; print([v['Name'] for k,v in json.load(sys.stdin)[0]['Containers'].items()])"
Sample output
[u'container1', u'container2']
I found that when a container has been brought up with an attribute of
network_mode: "service: <some service name>"
that the 'docker inspect' or 'docker network inspect ' commands are not going to give you the information as detailed above.
What you will see instead is something like this:
"NetworkMode": "container: <some container id representing the service>"
Allow me to contribute with another way of obtaining the result, still using docker network inspect, but providing other possibilities in terms of data inspection and output format.
You list the available networks for Docker:
$ docker network ls
NETWORK ID NAME DRIVER SCOPE
a1682358dfa3 bridge bridge local
c6910d1da750 host host local
c9790e542025 none null local
9b265ecb4042 web_default bridge local
You inspect the network, with output in JSON, accessing the Containers object + prettifying the JSON:
$ docker network inspect web_default -f '{{json .Containers}}' | python3 -m json.tool
{
"5d05c2606b022b0c9bc480f138b8f8f0e382dca4b1decb1c27181a66e641803f": {
"Name": "django",
"EndpointID": "b6bf6b1dc5437f2359fb550368a5bc6529cd80fa5b9ece3c752eecef6627ea57",
"MacAddress": "02:42:ac:12:00:03",
"IPv4Address": "172.18.0.3/16",
"IPv6Address": ""
},
"b971715bd0b3560831b03e86bcf2151ed04a60a46ad90b24f1f2265617360344": {
"Name": "postgres",
"EndpointID": "5883f465e235c66327271c1dfd05372f02012efa78928dd447c5444b0468647c",
"MacAddress": "02:42:ac:12:00:02",
"IPv4Address": "172.18.0.2/16",
"IPv6Address": ""
}
}
You can even redirect the command output to a for further inspection:
$ docker network inspect web_default -f '{{json .Containers}}' | python3 -m json.tool > web_default_containers.json
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.
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.
You can use docker inspect <container id>.
For example:
CID=$(docker run -d -p 4321 base nc -lk 4321);
docker inspect $CID
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"
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"
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
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}}' "$#"
}
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
Show all container's IP addresses:
docker inspect --format='{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -aq)
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"
}
}
]
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
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"
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
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.
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.
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'
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)
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
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
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}'
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'
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, the app.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.
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}'`
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"]'
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"
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.
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",
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",
For windows 10:
docker inspect --format "{{ .NetworkSettings.IPAddress }}" containerId
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
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/ \// /'