ධාරකයෙන් ඩොකර් බහාලුම්වල IP ලිපිනය ලබා ගන්නේ කෙසේද

නව බහාලුමක් නිර්මාණය කිරීමෙන් පසු ධාරකයේ සිට කන්ටේනරයේ IP ලිපිනය ලබා ගැනීමට මට ක්‍රියාත්මක කළ හැකි විධානයක් තිබේද?

මූලික වශයෙන්, ඩෝකර් විසින් කන්ටේනරය නිර්මාණය කළ පසු, මට මගේම කේත යෙදවීම සහ බහාලුම් වින්‍යාස කිරීමේ ස්ක්‍රිප්ට් රෝල් කිරීමට අවශ්‍යය.

මෙම --formatවිකල්පය inspectගලවා ගැනීමේ වෙතට පැමිණෙන්නේ නැත.

නවීන ඩෝකර් ග්‍රාහක වාක්‍ය ඛණ්ඩය:

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

පැරණි ඩෝකර් ග්‍රාහක වාක්‍ය ඛණ්ඩය:

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

මෙම විධානයන් විසින් ඩෝකර් බහාලුමේ IP ලිපිනය ලබා දෙනු ඇත.

අදහස් දැක්වීමේදී සඳහන් කර ඇති පරිදි: ඔබ වින්ඩෝස් හි සිටී නම්, කැරලි වරහන් වටා "තනි උපුටා දැක්වීම් වෙනුවට ද්විත්ව මිල ගණන් භාවිතා කරන්න '.

ඔබට භාවිතා කළ හැකිය docker inspect <container id>.

උදාහරණයක් වශයෙන්:

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

පළමුව බහාලුම් හැඳුනුම්පත ලබා ගන්න:

docker ps

(පළමු තීරුව බහාලුම් හැඳුනුම්පත සඳහා වේ)

ධාවනය කිරීමට බහාලුම් හැඳුනුම්පත භාවිතා කරන්න:

docker inspect <container ID>

පතුලේ, "ජාල සැකසුම්" යටතේ, ඔබට "IPAddress" සොයාගත හැකිය

නැතහොත් කරන්න:

docker inspect <container id> | grep "IPAddress"

docker inspect CONTAINER_ID | grep "IPAddress"

-iනඩුව නොසලකා හැරීම සඳහා ඔබට grep වෙත එකතු කළ හැකිය, එවිට පහත සඳහන් දෑ පවා ක්‍රියාත්මක වනු ඇත:

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

සියලුම බහාලුම් නම් සහ ඒවායේ 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

ඔබගේ ~/.bashrcහෝ අදාළ ගොනුවේ මෙම ෂෙල් ස්ක්‍රිප්ට් එක් කරන්න :

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

ඉන්පසු, කන්ටේනරයක IP ලිපිනයක් ලබා ගැනීම සඳහා මෙය කරන්න:

docker-ip YOUR_CONTAINER_ID

ඩෝකර් හි නව අනුවාදය සඳහා, කරුණාකර පහත සඳහන් දෑ භාවිතා කරන්න:

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

සියලුම බහාලුම්වල IP ලිපින පෙන්වන්න:

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

ඩෝකර් 1.3+ හි, ඔබට මෙය භාවිතා කර පරීක්ෂා කළ හැකිය:

ධාවනය වන ඩොකර් (ලිනක්ස්) ඇතුළත් කරන්න:

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

ඩෝකර් අනුවාදය 1.10.3 අනුව, 20f81dd සාදන්න

ඔබ ඩොකර්ට වෙනත් ආකාරයකින් නොකියන්නේ නම්, ඩෝකර් සෑම විටම පාලම් ජාලය තුළ ඔබේ බහාලුම් දියත් කරයි. එබැවින් ඔබට මෙම විධානය පහත උත්සාහ කළ හැකිය:

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

CONTAINER ID අගය භාවිතා කරන්න:

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

"172.17.0.2"

මා ආදරය කළ සමහර පිළිතුරු මත පදනම්ව, සියලු අයිපී ලිපින ලබා ගැනීම සඳහා ශ්‍රිතයකට ඒවා ඒකාබද්ධ කිරීමට මම තීරණය කළෙමි. ඒවා දැන් මගේ .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

නම අනුව බහාලුම් යොමු කරන්න:

docker run ... --name pg-master

ඉන්පසු IP ලිපින ලිපිනය නමින් ලබා ගන්න:

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

යටින් ධාවනය වන සියලුම බහාලුම් වලින් IP ලිපින වගුවක් ලබා ගැනීම සඳහා මම පහත දැක්වෙන Bash ස්ක්‍රිප්ට් ලිවීය 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
}

ඔබ විචල්ය ජාලය ඔබේම ජාල නාමයට වෙනස් කළ යුතුය.

මෙන්න ඉක්මන් වැඩ කරන පිළිතුරක්:

ඔබේ බහාලුම් නම හෝ හැඳුනුම්පත ලබා ගන්න:

docker container ls

ඉන්පසු IP ලබා ගන්න:

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

වරාය ලබා ගන්න:

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

ඩෝකර් යන්න Go හි ලියා ඇති අතර එය විමසුම් අරමුණු සඳහා Go syntax භාවිතා කරයි.

විශේෂිත භාජනයක IP ලිපිනය පරීක්ෂා කිරීම සඳහා, ඔබ විධානය ක්‍රියාත්මක කළ යුතුය ( -f"ආකෘතිය" සඳහා):

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

බහාලුම් හැඳුනුම්පත හෝ නම සඳහා, ඔබට විධානය ක්‍රියාත්මක කළ හැකිය

docker container ls

එය ධාවනය වන සෑම බහාලුමක්ම ලැයිස්තුගත කරයි.

මෙන්න මම අද පයිතන් හි සංවර්ධනය කළ විසඳුමකි docker inspect container , දත්ත ප්‍රභවය ලෙස JSON ප්‍රතිදානය .

මා සතුව බහාලුම් හා යටිතල පහසුකම් රාශියක් ඇති අතර, ඕනෑම බහාලුමකින් මූලික ජාල තොරතුරු වේගවත් හා ලස්සන ලෙස ලබා ගත යුතුය. ආකාරයකින් ලබා ගත යුතුය. ඒකයි මම මේ පිටපත හැදුවේ.

වැදගත්: 1.9 අනුවාදයේ සිට, ඩෝකර් ඔබට බහු ජාල නිර්මාණය කිරීමට සහ ඒවා බහාලුම්වලට ඇමිණීමට ඉඩ දෙයි.

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

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

කෝ-ඩොස්ගේ පිළිතුර දීර් extend කිරීම සඳහා, සියලු බහාලුම් නම් සහ ඒවායේ 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 exec -it <container id or name> hostname -i

උදා

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

සටහන!!! ඩෝකර් රචනා භාවිතය සඳහා:

ඩෝකර් රචනා එක් එක් පොකුරු සඳහා හුදකලා ජාලයක් නිර්මාණය කරන බැවින්, පහත ක්‍රම සමඟ ක්‍රියා නොකරයි docker-compose.

වඩාත්ම අලංකාර සහ පහසුම ක්‍රමය වන්නේ ෂෙල් ශ්‍රිතය නිර්වචනය කිරීමයි, දැනට වැඩිපුරම ඡන්දය දුන් පිළිතුර @ වවුටර්ඩීගේ :

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

ඩොකර්ට ලිනක්ස් වැඩසටහන් වැනි ගොනුවකට බහාලුම් හැඳුනුම්පත් ලිවිය හැකිය:

සමඟ ධාවනය --cidfile=filenameවන ඩොකර් කන්ටේනරයේ හැඳුනුම්පත "ගොනු නාමයට" දමයි.

වැඩි විස්තර සඳහා " ඩෝකර් PID සමාන කොටස ධාවනය කරයි " බලන්න .

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

PID ගොනුවක් භාවිතා කිරීම:

1. --cidfileපරාමිතිය සමඟ බහාලුම් ධාවනය කිරීම , app.cidගොනු අන්තර්ගතය මෙසේ ය:

   a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
   

2. ඩෝකර් බහාලුම් පරීක්ෂා කිරීමට ඔබට ගොනු අන්තර්ගතය භාවිතා කළ හැකිය:

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

3. පේළිගත කළ පයිතන් ස්ක්‍රිප්ට් භාවිතයෙන් ඔබට බහාලුම් අයිපී උපුටා ගත හැකිය:

   $ 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'])

වැඩි විස්තර සඳහා " ඩෝකර් බහාලුම් IP ලිපින ලබා ගැනීමේ විකල්ප 10 " බලන්න .

ඔබ ඩෝකර් මෙවලම් පෙට්ටිය භාවිතයෙන් ඩොකර් ස්ථාපනය කර ඇත්නම්, කන්ටේනර් අයිපී ලිපිනය ලබා ගැනීමට ඔබට කයිටේමැටික් යෙදුම භාවිතා කළ හැකිය:

1. කන්ටේනරය තෝරන්න
2. සැකසීම් මත ක්ලික් කරන්න
3. වරාය පටිත්ත ක්ලික් කරන්න.

බහාලුමක IP ලිපිනය සහ ධාරක වරාය ලබා ගැනීම සඳහා:

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

ප්‍රතිදානය:

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

කවුළු 10 සඳහා:

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

සම්පූර්ණත්වය සඳහා:

මම --formatවිකල්පයට ඇත්තෙන්ම කැමතියි , නමුත් මුලදී මම ඒ ගැන නොදැන සිටි නිසා එකම ප්‍රති result ලය ලබා ගැනීම සඳහා මම සරල පයිතන් වන්-ලයිනර් භාවිතා කළෙමි:

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

ඩොකර් රූප නාමය මත පදනම්ව බහාලුම් හැඳුනුම්පත සොයා ගැනීම සමඟ පෙර පිළිතුරු ඒකාබද්ධ කිරීම:

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

මෙය ධාරකයේ ඇති සියලුම බහාලුම් අයිපී ලැයිස්තුගත කරයි:

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

සියලුම බහාලුම් අයිපී සහ එහි නම් මුද්‍රණය කිරීම සඳහා ඩෝකර් පරික්ෂා කිරීම

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

ටර්මිනලයේ සිට විධාන ක්‍රියාත්මක කිරීම සඳහා විසඳුමක් සෙවීම සඳහා ගූගල් වෙතින් පැමිණි අයට (ස්ක්‍රිප්ට් එකකින් නොව ), ස්වයංක්‍රීයව සහ යෝජනා සහිත අන්තර්ක්‍රියාකාරී 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"

භාවිත:

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

සඳහා වින්ඩෝස් කන්ටේනර් භාවිතය

docker exec <container> ipconfig

කන්ටේනරයේ නම හෝ හැඳුනුම්පත කොහිද <container>?

docker psකන්ටේනරයේ හැඳුනුම්පත සොයා ගැනීමට ඔබට භාවිතා කළ හැකිය.