您可以使用docker inspect <container id>。

例如：

CID=$(docker run -d -p 4321 base nc -lk 4321);docker inspect $CID

inspect的--format选项来救援。

现代Docker客户端语法是：

docker inspect -f '\{\{range.NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' container_name_or_id

旧的Docker客户端语法是：

docker inspect --format '\{\{ .NetworkSettings.IPAddress }}' container_name_or_id

这些命令将返回Docker容器的IP地址。

如评论中所述：如果您使用的是Windows，请在花括号周围使用双引号"而不是单引号'。

在Docker 1.3+中，您还可以使用以下命令进行检查：

输入正在运行的Docker（Linux）：

docker exec [container-id or container-name] cat /etc/hosts172.17.0.26 d8bc98fa4088127.0.0.1   localhost::1 localhost ip6-localhost ip6-loopbackfe00::0 ip6-localnetff00::0 ip6-mcastprefixff02::1 ip6-allnodesff02::2 ip6-allrouters172.17.0.17 mysql

对于windows：

docker exec [container-id or container-name] ipconfig

在~/.bashrc或相关文件中添加此外壳脚本：

docker-ip() {docker inspect --format '\{\{ .NetworkSettings.IPAddress }}' "$@"}

然后，要获取容器的IP地址，只需执行以下操作：

docker-ip YOUR_CONTAINER_ID

对于新版本的Docker，请使用以下内容：

docker-ip() {docker inspect --format '\{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' "$@"}

为了扩展ko-dos的答案，这里有一个别名，列出了所有容器名称及其IP地址：

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'

按名称引用容器：

docker run ... --name pg-master

然后按名称获取IP地址：

MASTER_HOST=$(docker inspect --format '\{\{ .NetworkSettings.IPAddress }}' pg-master)

检查对我不起作用。也许是因为我使用了-net host和一些命名空间。

不管怎样，我发现这个很好地工作：

docker exec -i -t NAME /sbin/ifconfig docker0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'

我编写了以下Bash脚本来从docker-compose下运行的所有容器中获取IP地址表。

function docker_container_names() {docker ps -a --format "\{\{.Names}}" | xargs}
# Get the IP address of a particular containerdip() {local networknetwork='YOUR-NETWORK-HERE'docker inspect --format "\{\{ .NetworkSettings.Networks.$network.IPAddress }}" "$@"}
dipall() {for container_name in $(docker_container_names);dolocal container_ip=$(dip $container_name)if [[ -n "$container_ip" ]]; thenecho $(dip $container_name) " $container_name"fidone | sort -t . -k 3,3n -k 4,4n}

您应该将变量网络更改为您自己的网络名称。

为了完整性：

我真的很喜欢--format选项，但一开始我并没有意识到它，所以我使用了一个简单的Python单行代码来获得相同的结果：

docker inspect <CONTAINER> |python -c 'import json,sys;obj=json.load(sys.stdin);print obj[0]["NetworkSettings"]["IPAddress"]'

结合之前的答案并根据Docker映像名称查找容器ID：

docker inspect --format '\{\{ .NetworkSettings.IPAddress }}' `docker ps | grep $IMAGE_NAME | sed 's/\|/ /' | awk '{print $1}'`

如果您使用Docker Toolbox安装Docker，您可以使用Kit的应用程序来获取容器IP地址：

1. 选择容器
2. 点击设置
3. 单击端口选项卡。

只需一个命令即可获取所有容器名称及其IP地址。

docker inspect -f '\{\{.Name}} - \{\{.NetworkSettings.IPAddress }}' $(docker ps -aq)

如果您使用的是docker-compose，则命令将是：

docker inspect -f '\{\{.Name}} - \{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' $(docker ps -aq)

输出将是：

/containerA - 172.17.0.4/containerB - 172.17.0.3/containerC - 172.17.0.2

执行：

docker ps -a

这将显示活动的docker映像：

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                       PORTS               NAMES3b733ae18c1c        parzee/database     "/usr/lib/postgresql/"   6 minutes ago       Up 6 minutes                 5432/tcp            serene_babbage

使用CONTAINER ID值：

docker inspect <CONTAINER ID> | grep -w "IPAddress" | awk '{ print $2 }' | head -n 1 | cut -d "," -f1

“172.17.0.2”

如果您想快速查看所有Docker IP地址，或者不输入实例名称，您可以破解docker ps命令，将其添加到~/.bashrc文件中：

function docker-ips() {docker ps | while read line; doif `echo $line | grep -q 'CONTAINER ID'`; thenecho -e "IP ADDRESS\t$line"elseCID=$(echo $line | awk '{print $1}');IP=$(docker inspect -f "\{\{ .NetworkSettings.IPAddress }}" $CID);printf "${IP}\t${line}\n"fidone;}

这来自Docker GitHub上安德鲁·约翰斯通的提议：https://github.com/docker/docker/issues/8786

for containerId in $(sudo docker ps -a | cut -f1 -d' ' | grep -v CONTAINER); doecho " ContainerId - $containerId >>  $(sudo docker inspect --format '\{\{ .NetworkSettings.IPAddress }}' $containerId) "done

注意！！！用于Docker撰写使用：

由于Docker Compose为每个集群创建一个隔离的网络，因此以下方法不适用于docker-compose。

最优雅和简单的方法是定义shell函数，目前投票最多的答案@吴恩达：

dockip() {docker inspect --format '\{\{ .NetworkSettings.IPAddress }}' "$@"}

Docker可以像Linux程序一样将容器ID写入文件：

使用--cidfile=filename运行时，Docker将容器的ID转储为“filename”。

有关更多信息，请参阅“Docker运行PID等效部分”。

--cidfile="app.cid": Write the container ID to the file

使用PID文件：

1. 使用--cidfile参数运行容器，app.cid文件内容如下：

   a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909

2. You can use file content to inspect Docker containers:

   blog-v4 git:(develop) ✗ docker inspect `cat app.cid`

3. 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 jsonimport sys
sys.stdout.write(json.load(sys.stdin)[0]['NetworkSettings']['IPAddress'])

有关更多信息，请参阅“获取Docker容器IP地址的10种替代方案”。

从Docker版本1.10.3开始，构建20f81dd

除非您另有说明，否则Docker始终会在桥接网络中启动您的容器。所以你可以尝试下面的命令：

docker network inspect bridge

然后，它应该返回一个容器部分，该部分将显示该正在运行的容器的IP地址。

[{"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"}}]

docker inspect --format '\{\{ .NetworkSettings.IPAddress }}' <containername or containerID here>

如果将容器部署到默认网桥网络，则上述操作有效。

但是，如果使用自定义网桥网络或覆盖网络，我发现下面的方法可以更好地工作：

docker exec <containername or containerID here> /sbin/ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'

显示所有容器的IP地址：

docker inspect --format='\{\{.Name}} - \{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' $(docker ps -aq)

用途：

docker inspect $CID | grep IPAddress | grep -v null| cut -d '"' -f 4 | head -1

基于我喜欢的一些答案，我决定将它们合并到一个函数中以获取所有IP地址，并将另一个用于特定容器。它们现在在我的.bashrc文件中。

docker-ips() {docker inspect --format='\{\{.Name}} - \{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' $(docker ps -aq)}
docker-ip() {docker inspect --format '\{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' "$@"}

第一个命令给出所有容器的IP地址，第二个命令给出特定容器的IP地址。

docker-ipsdocker-ip YOUR_CONTAINER_ID

对于那些从Google来寻找从终端（而不是脚本）执行命令的解决方案的人来说，“jid”是一个具有自动完成和建议的交互式JSON向下钻取实用程序，可以让您用更少的键入来做同样的事情。

docker inspect $CID | jid

键入Tab. NetTab，您将看到如下内容：

[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": "",

输入.IPATab，你会看到类似的内容：

[Filter]> .[0].NetworkSettings.IPAddress"172.17.0.2"

docker inspect CONTAINER_ID | grep "IPAddress"

您可以将-i添加到grep以忽略案例，然后甚至可以使用以下方法：

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

要获取容器的IP地址和主机端口：

docker inspect containerId | awk '/IPAddress/ || /HostPort/'

输出：

    "HostPort": "4200""HostPort": "4200""SecondaryIPAddresses": null,"IPAddress": "172.17.0.2","IPAddress": "172.17.0.2",

这是我今天用Python开发的一个解决方案，使用docker inspect container JSON输出作为数据源。

我有很多容器和基础设施需要检查，我需要以快速和漂亮的方式从任何容器中获取基本的网络信息。这就是我制作这个脚本的原因。

重要事项：从1.9版开始，Docker允许您创建多个网络并将它们附加到容器。

#!/usr/bin/python
import jsonimport subprocessimport 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 Subprocessproc = 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]" % networkprint "\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'])

输出是：

$ 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.1IPv6 settings:            null/null   null
[backend]
02:42:ac:13:00:02   IP/NETWORK        GATEWAY--------------------------------------------IPv4 settings:      172.19.0.2/16     172.19.0.1IPv6 settings:            null/null   null

我必须通过docker容器名称提取docker容器IP地址，以便在部署脚本中进一步使用。为此，我编写了以下bash命令：

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\}'

假设将其放入bash脚本中可能很方便，该脚本期望my_container_name作为参数…

首先获取容器ID：

docker ps

（第一列是容器ID）

使用容器ID运行：

docker inspect <container ID>

在底部，在网络配置下，您可以找到ip地址

或者只是做基于UNIX的：

docker inspect <container id> | grep "IPAddress"

对于Windows CMD：

docker inspect <container id> | findstr "IPAddress"

docker inspect <container id> | grep -i ip

例如：

docker inspect 2b0c4b617a8c | grep -i ip

对于Windows 10：

docker inspect --format "\{\{ .NetworkSettings.IPAddress }}"  containerId

windows容器使用

docker exec <container> ipconfig

其中<container>是容器的姓名或id。

您可以使用docker ps来查找容器的ID。

Docker是用Go编写的，它也使用Go语法进行查询。

要检查特定容器的IP地址，您需要运行命令（-f表示“格式”）：

docker inspect -f '\{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' container_id_or_name

对于容器ID或名称，您可以运行命令

docker container ls

它将列出每个正在运行的容器。

如果您忘记了容器ID或不想使用shell命令进行操作，最好使用像Portainer这样的UI。

https://portainer.io/

$ 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

在那里，您可以找到有关容器IP的所有信息。

此脚本将获取所有正在运行的容器的IPv4地址，而无需进一步处理或解释结果。如果您也不想要容器名称，您可以删除“echo-n$NAME：”行。非常适合自动化或填充变量。

#!/bin/shfor NAME in $(docker ps --format \{\{.Names}})doecho -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

如果你想这样做，你也可以创建一个别名：

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"'

docker inspect <container id> | grep -i "ipaddress"

在Windows PowerShell中尝试：

     docker inspect -f "\{\{ .NetworkSettings.Networks.nat.IPAddress }}" <container id>

这里有一个快速的工作答案：

获取您的容器名称或ID：

docker container ls

然后获取IP：

docker inspect <container_ID Or container_name> |grep 'IPAddress'

获取端口：

docker inspect <container_ID Or container_name> |grep 'Port'

docker inspect --format "\{\{ .NetworkSettings.Networks.mynetwork.IPAddress }}" <containername or containerID here>

上面的是Windows容器，其中已经使用

docker create network mynetwork

这将列出主机上的所有容器IP：

sudo docker ps -aq | while read line;  do sudo docker inspect -f '\{\{.Name}} - \{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' $line ; done

还没有人提出Docker Python API。获取IP地址的Docker API解决方案相当简单。

*基于NIX的操作系统： docker api 3.7（更新感谢评论中的加拿大）

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"]

操作系统不可知： docker api 4.0. x（感谢评论中的pds添加）

import docker
client = docker.from_env()container = client.containers.get(container_name)vars( container )["attrs"]["NetworkSettings"]["Networks"]["<NETWORK_NAME>"]["IPAddress"]

不是太难找到，但很有用。此外，这可以很容易地修改以找到分配给各种网络上容器的所有IP。

docker inspect MY_CONTAINER | jq -r '.[].NetworkSettings.Networks[].IPAddress'

加上

• 优雅的语法
• 灵活（一旦你使用jq，你可以在任何有json的地方使用它，非常有用）
• 强大

减

• 需要安装jq（例如apt-get install jq）

公认的答案涵盖了如何打字相当好，但这里有一个小改进：

docker container inspect \--format '\{\{range .NetworkSettings.Networks}}\{\{.IPAddress}} \{\{end}}' \$container_id_or_name

这使用docker container inspect而不是更通用的docker inspect，因为docker在他们的命令中转向名词+动词语法，并消除了你正在检查的内容的歧义。我还在IP地址后包含了一个空格，因为容器可以在多个docker网络上，具有多个IP地址。这可以换成任何其他对你有意义的字符或字符串。

对于那些想知道如何查找其他值的人，我经常使用以下内容将任何docker格式的语法输出到json中：

docker container inspect --format '\{\{json .}}' $container_id_or_name | jq .

您可能需要安装jq才能工作，或者您可以省略尾随命令以将json读取为单个长行。查看此输出时，您可以看到每个键名称及其父项，因此您可以创建自己的格式字符串来输出任何您想要的内容。格式语法是用Go语言模板和一些包含额外的docker特定功能实现的。

基本上，一旦Docker创建了容器，我想滚动我自己的代码部署和容器配置脚本。

我回答的主要原因是这条评论对我来说有一个巨大的危险信号。它表明你的图像不包含运行应用程序所需的一切，在使用容器时是一个很大的反模式。多年来，我有十几个客户端，我还没有找到一个真实的用例来通过Docker主机的内部IP地址直接连接到容器，这没有更好的选择。相反，如果你的容器中需要运行启动后配置，这通常是通过入口点脚本完成的。

还有一个危险信号，你正在绕过docker的网络模型。使用docker网络，有两种选择。首先，在容器之间通信时，这是通过用户创建的网络完成的，并使用docker的内置DNS通过名称或网络别名而不是通过重新创建容器时会更改的IP地址连接到容器。对于从docker外部到容器的通信，这是通过从docker主机发布一个端口到容器来完成的，然后连接到该端口上的主机，而不是直接连接到容器。如果您坚持使用这两个选项，您应该能够在不知道其内部IP地址的情况下访问您的应用程序。

如果您需要一个特定的方便别名来获取特定的容器ip，请使用此别名

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'

然后你可以得到你的容器ip

dockerip <containername>

您也可以使用容器ID而不是容器名称

顺便说一句，我接受了很好的答案，但没有产生干净的输出，所以我编辑了它，并像这样使用；

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'

接受的答案对于每个容器的多个网络效果不佳：

> docker inspect -f '\{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' cc54d96d63ea
172.20.0.4172.18.0.5

下一个最佳答案更接近：

> docker inspect cc54d96d63ea | grep "IPAddress"
"SecondaryIPAddresses": null,"IPAddress": "","IPAddress": "172.20.0.4","IPAddress": "172.18.0.5",

我喜欢使用jq来解析网络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}}

要列出每个容器的IP地址，则变成：

for s in `docker ps -q`; doecho `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",

Docker检查用于打印所有容器ips及其各自的名称

docker ps -q | xargs -n 1 docker inspect --format '\{\{range .NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}} \{\{ .Name }}' | sed 's/ \// /'

检查此脚本：https://github.com/jakubthedeveloper/DockerIps

它以以下格式返回容器名称及其IP：

abc_nginx 172.21.0.4abc_php 172.21.0.5abc_phpmyadmin 172.21.0.3abc_mysql 172.21.0.2

这对我来说很有效，我在docker工具箱18.09.3上运行，在windows 10家庭版：

键入命令'docker-Machine ls'

λdocker机器ls名称主动驱动程序状态URL SWARM DOCKER ERRORS默认*虚拟盒运行tcp://192.168.98.100:2376v18.09.6

它将在URL列下显示实际的IP。例如192.168.98.100

我用这个简单的方法

docker exec -it <container id or name> hostname -i

例如

ubuntu@myhost:~$ docker exec -it 3d618ac670fe hostname -i10.0.1.5

使用Python NewAPI：

import docker
client = docker.DockerClient()container = client.containers.get("NAME")ip_add = container.attrs['NetworkSettings']['IPAddress']print(ip_add)

另一个经典的解决方案：

docker ps -aq | xargs docker inspect -f '\{\{.Name}} - \{\{.NetworkSettings.IPAddress }}'

有多种方法可以从主机获取容器的IP

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

我有麻烦与我的多网络环境所以这是一个更动态的版本

获取驻留在一个撰写文件中的所有主机名、网络和IP

 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

产出

containerA [networkA:192.168.1.4] [networkB:192.168.2.4]containerB  [networkA:192.168.1.5]

要获取所有正在运行的容器，请替换第一个命令

for N in $(docker-compose ps -q)

与

 for N in $(docker container ls | awk 'NR>=2' | cut -c1-12 );

给定1个特定网络，获取1个特定容器（具有多个网络）的IP

docker inspect --format='\{\{range $i, $value := .NetworkSettings.Networks}}\{\{if eq $i "NETWORKNAME"}}\{\{.IPAddress}}\{\{end}}\{\{end}}' CONTAINERNAME

产出

192.168.1.4

给定1个特定网络，获取所有容器（具有多个网络）的主机名IP

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

产出

containerA 192.168.1.4containerB 192.168.1.5

给定1个特定网络，获取所有容器（具有多个网络）的IP

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

产出

192.168.1.4192.168.1.5

我的回答：

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

也作为bash别名：

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 }

输出按IP地址排序，制表符分隔：

# docker-ips172.18.0.2       memcached172.18.0.3       nginx172.18.0.4       fpm-backup172.18.0.5       dns172.18.0.6       fpm-beta172.18.0.7       exim172.18.0.8       fpm-delta172.18.0.9       mariadb172.18.0.10      fpm-alpha172.19.0.2       nextcloud-redis172.19.0.3       nextcloud-db172.19.0.4       nextcloud

Linux容器

.方法1

 docker exec postgres ifconfig

.方法2

  docker exec postgres cat /etc/hosts

.方法3

docker exec postgres ip a

.方法4

使用Powershell

docker inspect postgres | select-string 'ipaddress'

使用任意字符串提取IP：

我在这个问题中读到的许多解决方案都需要用户首先识别<容器名称>或<容器ID>的中间步骤，然后将其提供给他们的解决方案以揭示IP。

重新创建容器时，IP可能会发生变化，如果发生这种情况，任何引用它的脚本现在都将被破坏。

因此，我需要一种提取容器没有人工干预的IP的方法，以确保脚本一直都是具有正确的IP，即使它在每次重新创建容器时都发生了变化。

解决方案：

#!/bin/bash
# Only need to set "CONTAINERNAME" variable with an arbitrary# string found in either the Container ID or Image Name and# it prints container IP. Ensure the string is unique to desired host
CONTAINERNAME='mariadb-blog'CONTAINERID="$(docker ps | grep -i $CONTAINERNAME | awk '{print $1}')"CONTAINERIP="$(docker inspect -f '\{\{range.NetworkSettings.Networks}}\{\{.IPAddress}}\{\{end}}' $CONTAINERID)"
echo "$CONTAINERIP"

结论：

我已经用我自己的LinuxDocker-Compose主机测试了此脚本，截至20220722它工作可靠。事实上，复制-粘贴脚本很容易来验证我的结果是可重复的。

请注意：有一个潜在的可靠性致命弱点：如果你不剪切自己的docker映像并依赖于第三方，他们可能会更改映像的命名约定并破坏脚本中的grep。因此，我建议将任意字符串设置为容器名称，因为你可以控制它，确保字符串的grep始终成功并打印IP以提供给您的脚本。

没有人提到的最好方法是为容器分配一个主机名。

docker run -d --hostname localcontainerhostname imageName

这将为您提供IP地址，但您可能还是想使用主机名

nslookup localcontainerhostname

如果您在Windows上，您可能无法从docker inspect获得任何信息，在这种情况下，您最好的选择是实际使用ipconfig /all并查找以太网适配器v以太网（WSL）：部分，您可以在其中看到IPv4地址 . . . : xxx.xxx.xxx.xxx（首选）-这将是您可以在本地浏览器的URL中使用的IP。