Cara mendapatkan alamat IP kontainer Docker dari host

Apakah ada perintah yang bisa saya jalankan untuk mendapatkan alamat IP penampung langsung dari host setelah wadah baru dibuat?

Pada dasarnya, setelah Docker membuat wadah, saya ingin menggulirkan penerapan kode saya sendiri dan skrip konfigurasi wadah.

The --formatpilihan untuk inspectdatang untuk menyelamatkan.

Sintaks klien Docker modern adalah:

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

Sintaks klien Docker lama adalah:

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

Perintah-perintah ini akan mengembalikan alamat IP penampung Docker.

Seperti disebutkan dalam komentar: jika Anda menggunakan Windows, gunakan tanda kutip ganda "sebagai ganti tanda kutip tunggal di 'sekitar kurung kurawal.

Kamu bisa menggunakan docker inspect <container id> .

Sebagai contoh:

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

Pertama-tama dapatkan ID kontainer:

docker ps

(Kolom pertama untuk ID wadah)

Gunakan ID kontainer untuk menjalankan:

docker inspect <container ID>

Di bagian bawah, di bawah "NetworkSettings", Anda dapat menemukan "IPAddress"

Atau Lakukan saja:

docker inspect <container id> | grep "IPAddress"

docker inspect CONTAINER_ID | grep "IPAddress"

Anda dapat menambah -igrep untuk mengabaikan kasing kemudian bahkan yang berikut ini akan berfungsi:

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

Untuk mendapatkan semua nama kontainer dan alamat IP mereka hanya dalam satu perintah.

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

Jika Anda menggunakan docker-composeperintah akan seperti ini:

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

Outputnya adalah:

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

Tambahkan skrip shell ini di ~/.bashrcfile Anda atau yang relevan:

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

Kemudian, untuk mendapatkan alamat IP suatu wadah, cukup lakukan ini:

docker-ip YOUR_CONTAINER_ID

Untuk versi baru Docker, silakan gunakan yang berikut ini:

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

Tampilkan semua alamat IP penampung:

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

Di Docker 1.3+, Anda juga dapat memeriksanya menggunakan:

Masukkan Docker yang berjalan (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

Untuk windows:

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

Pada Docker versi 1.10.3, build 20f81dd

Kecuali Anda memberi tahu Docker sebaliknya, Docker selalu meluncurkan wadah Anda di jaringan jembatan. Jadi, Anda dapat mencoba perintah ini di bawah:

docker network inspect bridge

Yang kemudian akan mengembalikan bagian Wadah yang akan menampilkan alamat IP untuk wadah yang berjalan.

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

Menjalankan:

docker ps -a

Ini akan menampilkan gambar buruh pelabuhan aktif:

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

Gunakan nilai ID KONTAINER:

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

"172.17.0.2"

Berdasarkan beberapa jawaban yang saya sukai, saya memutuskan untuk menggabungkannya ke suatu fungsi untuk mendapatkan semua alamat IP dan lainnya untuk wadah tertentu. Mereka sekarang ada di .bashrcfile saya .

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

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

Perintah pertama memberikan alamat IP semua wadah dan yang kedua alamat IP wadah tertentu.

docker-ips
docker-ip YOUR_CONTAINER_ID

Referensi wadah dengan nama:

docker run ... --name pg-master

Kemudian ambil alamat alamat IP dengan nama:

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

Saya menulis skrip Bash berikut untuk mendapatkan tabel alamat IP dari semua kontainer yang berjalan di bawah 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
}

Anda harus mengubah jaringan variabel ke nama jaringan Anda sendiri.

Inilah jawaban cepat untuk bekerja:

Dapatkan nama atau ID wadah Anda:

docker container ls

Kemudian dapatkan IP:

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

Dapatkan port:

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

Docker ditulis dalam Go dan menggunakan sintaks Go untuk keperluan kueri juga.

Untuk memeriksa alamat IP wadah tertentu, Anda perlu menjalankan perintah ( -funtuk "format"):

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

Untuk ID atau nama kontainer, Anda dapat menjalankan perintah

docker container ls

yang akan mendaftar setiap wadah yang berjalan.

Berikut ini adalah solusi yang saya kembangkan hari ini di Python, menggunakan docker inspect containeroutput JSON sebagai sumber data.

Saya memiliki banyak wadah dan infrastruktur yang harus saya periksa, dan saya perlu mendapatkan informasi jaringan dasar dari wadah apa pun, dengan cepat dan cantik. . Itu sebabnya saya membuat skrip ini.

PENTING: Sejak versi 1.9, Docker memungkinkan Anda membuat beberapa jaringan dan melampirkannya ke wadah.

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

Outputnya adalah:

$ 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

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

Hal di atas berfungsi jika wadah digunakan untuk jaringan jembatan default.

Namun, jika menggunakan jaringan jembatan khusus atau jaringan overlay, saya menemukan di bawah ini berfungsi lebih baik:

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

Untuk memperluas jawaban ko-dos, berikut ini adalah alias untuk mencantumkan semua nama wadah dan alamat IP mereka:

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'

Saya menggunakan cara sederhana ini

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

misalnya

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

Jika Anda menginstal Docker menggunakan Docker Toolbox, Anda dapat menggunakan aplikasi Kitematic untuk mendapatkan alamat IP kontainer:

1. Pilih wadahnya
2. Klik Pengaturan
3. Klik di tab Ports.

Untuk mendapatkan alamat IP dan port host dari sebuah wadah:

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

Keluaran:

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

CATATAN!!! untuk Penggunaan Menulis Docker:

Karena Docker Compose membuat jaringan terisolasi untuk setiap cluster, metode di bawah ini tidak berfungsi docker-compose.

Cara paling elegan dan mudah adalah mendefinisikan fungsi shell, yang saat ini menjadi jawaban terbanyak dari @ WouterD :

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

Docker dapat menulis ID kontainer ke file seperti program Linux:

Berlari dengan --cidfile=filename , Docker membuang ID wadah ke "nama file".

Lihat " Docker menjalankan Bagian yang setara dengan PID " untuk informasi lebih lanjut.

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

Menggunakan file PID:

1. Menjalankan wadah dengan --cidfileparameter, app.cidkonten file seperti:

   a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
   

2. Anda dapat menggunakan konten file untuk memeriksa wadah Docker:

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

3. Anda bisa mengekstrak IP kontainer menggunakan skrip Python sebaris:

   $ 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
   

Ini bentuk yang lebih ramah manusia:

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

Lihat " 10 alternatif untuk mendapatkan alamat IP kontainer Docker " untuk informasi lebih lanjut.

Untuk windows 10:

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

Ini akan mencantumkan semua IP kontainer pada host:

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

Docker memeriksa penggunaan untuk mencetak semua ips wadah dan namanya masing-masing

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

Hanya untuk kelengkapan:

Saya sangat suka --formatopsi itu, tetapi pada awalnya saya tidak menyadarinya sehingga saya menggunakan Python satu-liner sederhana untuk mendapatkan hasil yang sama:

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

Menggabungkan jawaban sebelumnya dengan menemukan ID kontainer berdasarkan nama gambar Docker:

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

Menggunakan:

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

Untuk wadah Windows digunakan

docker exec <container> ipconfig

di mana <container>adalah nama atau id dari wadah.

Anda dapat menggunakan docker psuntuk menemukan id wadah.

Jika Anda lupa ID kontainer atau tidak ingin memanipulasi dengan perintah shell, lebih baik menggunakan UI seperti Portainer.

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

Di sana Anda dapat menemukan semua informasi tentang wadah juga IP.