如何从主机获取 Docker 容器的 IP 地址

Question

创建新容器后，是否可以运行命令从主机获取容器的 IP 地址？

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

Answer 1

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，请在大括号周围使用双引号"而不是单引号' 。

Answer 2

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

例如：

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

Answer 3

首先获取容器ID：

docker ps

（第一列是容器 ID）

使用容器 ID 运行：

docker inspect <container ID>

在底部的“网络设置”下，您可以找到“IP地址”

或者只是这样做：

docker inspect <container id> | grep "IPAddress"

Answer 4

docker inspect CONTAINER_ID | grep "IPAddress"

您可以将-i添加到 grep 以忽略大小写，那么即使以下内容也可以工作：

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

Answer 5

只需一个命令即可获取所有容器名称及其 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

Answer 6

在你的~/.bashrc或相关文件中添加这个 shell 脚本：

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

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

docker-ip YOUR_CONTAINER_ID

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

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

Answer 7

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

进入正在运行的 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

对于窗户：

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

Answer 8

显示所有容器的 IP 地址：

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

Answer 9

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

除非你另外告诉 Docker，否则 Docker 总是在桥接网络中启动你的容器。 所以你可以试试下面的这个命令：

docker network inspect bridge

然后应该返回一个 Containers 部分，该部分将显示该正在运行的容器的 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"
        }
    }
]

Answer 10

执行：

docker ps -a

这将显示活动的泊坞窗图像：

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

使用容器 ID 值：

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

“172.17.0.2”

Answer 11

根据我喜欢的一些答案，我决定将它们合并到一个函数中以获取所有 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-ips
docker-ip YOUR_CONTAINER_ID

Answer 12

这是一个快速的工作答案：

获取您的容器名称或 ID：

docker container ls

然后获取IP：

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

获取端口：

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

Answer 13

我的答案：

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

Answer 14

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

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
}

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

Answer 15

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

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

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

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

docker container ls

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

Answer 16

按名称引用容器：

docker run ... --name pg-master

然后按名称抓取IP地址：

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

Answer 17

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

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

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

#!/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'])

输出是：

$ 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

Answer 18

我用这个简单的方法

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

例如

ubuntu@myhost:~$ docker exec -it 3d618ac670fe hostname -i
10.0.1.5

Answer 19

为了扩展 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'

Answer 20

笔记！！！ 对于 Docker Compose 用法：

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

最优雅、最简单的方法是定义一个 shell 函数，这是目前投票最多的答案@WouterD ：

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

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

使用--cidfile=filename运行，Docker 将容器的 ID 转储到“文件名”。

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

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

使用PID文件：

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

 a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909

您可以使用文件内容来检查 Docker 容器：

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

您可以使用内联 Python 脚本提取容器 IP：

 $ 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

这是一种更人性化的形式：

#!/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'])

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

Answer 21

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

Answer 22

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

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

Answer 23

只是为了完整性：

我真的很喜欢--format选项，但一开始我并不知道它，所以我使用了一个简单的 Python one-liner 来获得相同的结果：

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

Answer 24

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

选择容器
点击设置
单击端口选项卡。

Answer 25

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

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

输出：

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

Answer 26

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

docker inspect $CID | jid

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

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

.IPA Tab ，你会看到类似的内容：

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

Answer 27

对于 Windows 10：

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

Answer 28

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

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

Answer 29

接受的答案不适用于每个容器的多个网络：

> 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`; 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",

Answer 30

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

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

Answer 31

创建新容器后，是否可以运行命令从主机获取容器的IP地址？

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

Answer 32

对于Windows容器使用

docker exec <container> ipconfig

其中<container>是<container>的名称或ID 。

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

Answer 33

如果您忘记了容器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的所有信息。

Answer 34

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

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

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。

Answer 35

检查对我不起作用。 也许当我使用-net host和一些命名空间时。

无论如何，我发现这很好用：

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

Answer 36

我必须通过 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\}'

Answer 37

docker inspect <container id> | grep -i ip

例如：

docker inspect 2b0c4b617a8c | grep -i ip

Answer 38

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

#!/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

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

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

Answer 39

我的多网络环境有问题，所以这是一个更动态的版本<\/em>

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

输出<\/em>
要获取所有正在运行的容器，请替换第一个命令
和
给定 1 个特定网络，获取 1 个特定容器（具有多个网络）的 IP<\/h2> docker inspect --format='{{range $i, $value := .NetworkSettings.Networks}}{{if eq $i "NETWORKNAME"}}{{.IPAddress}}{{end}}{{end}}' CONTAINERNAME<\/code><\/pre> 输出<\/em>
给定 1 个特定网络，获取所有容器（具有多个网络）的“主机名 IP”<\/h2> 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<\/code><\/pre> 输出<\/em>
给定 1 个特定网络，获取所有容器（具有多个网络）的 IP<\/h2> 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<\/code><\/pre> 输出<\/em>

Answer 40

在 Windows PowerShell 中尝试：

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

Answer 41

接受的答案准确地涵盖了要输入的内容，但这里有一个小的改进：

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

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

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

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

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

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

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

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

Answer 42

如果您需要特定的方便别名来获取特定的容器 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>

您也可以使用 containerid 而不是 containername

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

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'

Answer 43

检查此脚本： https<\/a> :\/\/github.com\/jakubthedeveloper\/DockerIps

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

abc_nginx 172.21.0.4
abc_php 172.21.0.5
abc_phpmyadmin 172.21.0.3
abc_mysql 172.21.0.2

Answer 44

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

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;
}

Answer 45

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

以上适用于已设置网络的 Windows 容器

docker create network mynetwork

Answer 46

docker inspect MY_CONTAINER | jq -r '.[].NetworkSettings.Networks[].IPAddress'<\/code>

加

优雅的语法<\/li>
灵活（一旦你使用 jq，你可以在任何有 json 的地方使用它，非常有用）<\/li>
强大的<\/li><\/ul>减需要安装 jq（例如 apt-get install jq）<\/li><\/ul>"

Answer 47

只是另一个经典的解决方案：

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

Answer 48

这对我有用，我在 Windows 10 家庭版的 docker-toolbox 18.09.3 上运行：

输入命令'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

它会在 URL 列下显示实际 IP。 例如'192.168.98.100'

Answer 49

使用Python<\/code>新API<\/code> ：

import docker

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

Answer 50

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

如果您不记得上面的命令，您可以随时执行以下操作<\/strong>

返回信息后，它将返回有关 Docker 对象的低级信息查找"Networks"<\/code> ，在其中您将找到容器的"IPAddress"<\/code>

Answer 51

Linux 容器<\/strong>


      
       使用 Powershell
 docker 检查 postgres | 选择字符串'ipaddress'

Answer 52

使用任意字符串提取 IP：

几乎所有我在这个问题中阅读的解决方案都需要用户首先识别<container name>或<container 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"

结论：

我已经用我自己的 Linux Docker-Compose 主机测试了这个脚本，它从 20220722 开始可靠地工作。事实上，很容易复制粘贴脚本来验证我的结果是可重现的。

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

Answer 53

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

docker run -d --hostname localcontainerhostname imageName

这将为您提供 ip 地址，但您可能仍想使用主机名

nslookup localcontainerhostname

Answer 54

如果你在 Windows，你可能无法从docker inspect获得任何信息，在这种情况下你最好的选择是实际使用ipconfig /all并寻找Ethe.net 适配器 vEthe.net (WSL)：你可以看到的部分一个IPv4 地址。 . . ：xxx.xxx.xxx.xxx（首选） - 这将是您可以在本地浏览器上的 url 中使用的 IP。

Answer 55

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

"

Answer 56

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

如何从主机获取 Docker 容器的 IP 地址

问题描述

56 个解决方案

解决方案1 2898 已采纳 2013-12-19 15:56:21

解决方案2 547 2013-06-17 22:37:03

解决方案3 468 2017-09-19 22:08:01

解决方案4 248 2017-01-04 20:01:51

解决方案5 170 2016-01-12 16:52:29

解决方案6 102 2014-11-18 00:04:31

解决方案7 46 2014-11-02 00:05:48

解决方案8 41 2016-04-27 07:50:02

解决方案9 33 2016-04-08 14:06:14

解决方案10 30 2016-01-18 20:01:20

解决方案11 26 2016-10-05 20:25:02

解决方案12 20 2018-06-07 10:46:18

解决方案13 20 2020-07-21 21:29:18

解决方案14 19 2015-07-22 09:57:00

解决方案15 18 2017-10-28 03:42:30

解决方案16 17 2015-04-23 14:08:29

解决方案17 16 2017-02-22 23:06:13

解决方案18 12 2019-09-11 09:55:42

解决方案19 9 2015-03-05 20:34:03

解决方案20 9 2016-03-30 10:50:15

解决方案21 9 2016-04-18 10:12:20

解决方案22 8 2015-11-30 22:39:32

解决方案23 7 2015-10-08 15:54:04

解决方案24 7 2015-12-25 20:59:49

解决方案25 7 2017-02-15 14:54:03

解决方案26 6 2016-12-12 16:06:35

解决方案27 6 2017-10-08 10:46:00

解决方案28 6 2018-07-31 06:52:56

解决方案29 6 2019-02-28 10:12:07

解决方案30 6 2019-03-14 06:09:25

解决方案31 5 2016-07-28 18:07:48

解决方案32 4 2017-10-25 17:03:15

解决方案33 4 2017-12-04 13:11:42

解决方案34 4 2018-08-17 06:47:36

解决方案35 3 2015-06-04 18:05:10

解决方案36 3 2017-08-26 18:59:32

解决方案37 3 2017-10-08 04:11:33

解决方案38 3 2018-02-06 20:52:24

解决方案39 3 2020-07-03 18:57:42

获取驻留在一个撰写文件中的所有主机名、网络和 IP<\/h2>输出<\/em>

给定 1 个特定网络，获取所有容器（具有多个网络）的 IP<\/h2> 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<\/code><\/pre> 输出<\/em>

解决方案40 2 2018-05-13 09:49:45

解决方案41 2 2018-09-05 12:55:12

解决方案42 2 2019-01-11 11:32:21

解决方案43 2 2019-06-27 09:58:57

解决方案44 1 2016-02-07 21:34:52

解决方案45 1 2018-07-16 08:22:39

解决方案46 1 2018-08-24 09:36:54

解决方案47 1 2019-11-07 23:23:48

解决方案48 0 2019-07-25 09:31:18

解决方案49 0 2019-10-22 10:25:21

解决方案50 0 2019-11-16 13:18:55

解决方案51 0 2022-02-04 04:09:50

解决方案52 0 2022-07-22 15:47:38

使用任意字符串提取 IP：

解决方案：

结论：

解决方案53 0 2022-10-27 19:51:20

解决方案54 0 2022-11-22 05:55:03

解决方案55 -1 2018-05-03 18:32:59

解决方案56 -6 2016-02-10 09:30:46

解决方案1
2898 已采纳 2013-12-19 15:56:21

解决方案2
547 2013-06-17 22:37:03

解决方案3
468 2017-09-19 22:08:01

解决方案4
248 2017-01-04 20:01:51

解决方案5
170 2016-01-12 16:52:29

解决方案6
102 2014-11-18 00:04:31

解决方案7
46 2014-11-02 00:05:48

解决方案8
41 2016-04-27 07:50:02

解决方案9
33 2016-04-08 14:06:14

解决方案10
30 2016-01-18 20:01:20

解决方案11
26 2016-10-05 20:25:02

解决方案12
20 2018-06-07 10:46:18

解决方案13
20 2020-07-21 21:29:18

解决方案14
19 2015-07-22 09:57:00

解决方案15
18 2017-10-28 03:42:30

解决方案16
17 2015-04-23 14:08:29

解决方案17
16 2017-02-22 23:06:13

解决方案18
12 2019-09-11 09:55:42

解决方案19
9 2015-03-05 20:34:03

解决方案20
9 2016-03-30 10:50:15

解决方案21
9 2016-04-18 10:12:20

解决方案22
8 2015-11-30 22:39:32

解决方案23
7 2015-10-08 15:54:04

解决方案24
7 2015-12-25 20:59:49

解决方案25
7 2017-02-15 14:54:03

解决方案26
6 2016-12-12 16:06:35

解决方案27
6 2017-10-08 10:46:00

解决方案28
6 2018-07-31 06:52:56

解决方案29
6 2019-02-28 10:12:07

解决方案30
6 2019-03-14 06:09:25

解决方案31
5 2016-07-28 18:07:48

解决方案32
4 2017-10-25 17:03:15

解决方案33
4 2017-12-04 13:11:42

解决方案34
4 2018-08-17 06:47:36

解决方案35
3 2015-06-04 18:05:10

解决方案36
3 2017-08-26 18:59:32

解决方案37
3 2017-10-08 04:11:33

解决方案38
3 2018-02-06 20:52:24

解决方案39
3 2020-07-03 18:57:42

给定 1 个特定网络，获取所有容器（具有多个网络）的 IP<\/h2>
`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<\/code><\/pre> 输出<\/em>`

解决方案40
2 2018-05-13 09:49:45

解决方案41
2 2018-09-05 12:55:12

解决方案42
2 2019-01-11 11:32:21

解决方案43
2 2019-06-27 09:58:57

解决方案44
1 2016-02-07 21:34:52

解决方案45
1 2018-07-16 08:22:39

解决方案46
1 2018-08-24 09:36:54

解决方案47
1 2019-11-07 23:23:48

解决方案48
0 2019-07-25 09:31:18

解决方案49
0 2019-10-22 10:25:21

解决方案50
0 2019-11-16 13:18:55

解决方案51
0 2022-02-04 04:09:50

解决方案52
0 2022-07-22 15:47:38

解决方案53
0 2022-10-27 19:51:20

解决方案54
0 2022-11-22 05:55:03

解决方案55
-1 2018-05-03 18:32:59

解决方案56
-6 2016-02-10 09:30:46