Como obter o endereço IP do contêiner do Docker do host?

Existe um comando que eu possa executar para obter o endereço IP do contêiner diretamente do host depois que um novo contêiner é criado?

Basicamente, uma vez que o Docker cria o contêiner, eu quero rolar meus próprios scripts de implantação de código e configuração de contêiner.

A opção --format de inspecionar vem para o resgate.

Sintaxe do cliente do Docker moderno:

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

Sintaxe do cliente do Docker antigo:

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

Que retornará apenas o endereço IP.

Você pode usar a docker inspect

Exemplo:

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

Primeiro, pegue o ID do contêiner:

 docker ps 

(A primeira coluna é para o ID do contêiner)

Use o ID do contêiner para executar:

 docker inspect  

Na parte inferior, em “NetworkSettings”, você pode encontrar “IPAddress”

Ou apenas faça:

 docker inspect  | grep "IPAddress" 

docker inspect | grep "IPAddress"

Para obter todos os nomes de contêiner e seus endereços IP em apenas um único comando.

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

Se você estiver usando o docker-compose o comando será:

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

A saída será:

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

Adicione este script de shell em seu arquivo ~/.bashrc ou relevante:

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

Então, para obter um endereço IP de um container, simplesmente faça o seguinte:

 docker-ip YOUR_CONTAINER_ID 

Para a nova versão do Docker, use o seguinte:

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

Mostrar todos os endereços IP dos contêineres:

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

No Docker 1.3+, você também pode ver as etapas abaixo:

Entre no Docker em execução:

 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 

A partir do Docker versão 1.10.3, compilation 20f81dd

A menos que você tenha informado ao Docker o contrário, o Docker sempre lança seus contêineres na rede da ponte. Então você pode tentar este comando abaixo:

 docker network inspect bridge 

Que deve então retornar uma seção de Contêineres que exibirá o endereço IP desse contêiner em execução.

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

Executar:

 docker ps -a 

Isso exibirá imagens do docker ativo:

 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 o valor da ID do CONTENTOR:

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

“172.17.0.2”

Com base em algumas das respostas que eu amei, decidi mesclá-las a uma function para obter todos os endereços IP e outra para um contêiner específico. Eles estão agora no meu arquivo .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}}' "$@" } 

O primeiro comando fornece o endereço IP de todos os contêineres e o segundo endereço IP de um contêiner específico.

 docker-ips docker-ip YOUR_CONTAINER_ID 

Recipientes de referência por nome:

 docker run ... --name pg-master 

Em seguida, pegue o endereço de endereço IP pelo nome:

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

O Docker é feito internamente no Go e usa a syntax Go para fins de consulta também.

Para inspecionar sobre o endereço IP de um contêiner específico, você precisa executar o comando (-f para opção de formato)

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

Para ID ou nome do contêiner, você pode executar o docker container ls comando docker container ls . Ele listará todos os contêineres em execução.

Escrevi o script Bash a seguir para obter uma tabela de endereços IP de todos os contêineres em execução no 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 } 

Você deve alterar a rede de variables ​​para o seu próprio nome de rede.

Aqui está uma solução que desenvolvi hoje em Python, usando a saída JSON “docker inspect container” como fonte de dados.

Tenho muitos contêineres e infraestruturas que preciso inspecionar e preciso obter informações básicas de rede de qualquer contêiner, de maneira rápida e bonita . É por isso que fiz esse roteiro.

IMPORTANTE: Desde a versão 1.9, o Docker permite criar várias redes e anexá-las aos contêineres.

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

A saída é assim:

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

O acima funciona se o contêiner for implantado na rede de ponte padrão.

No entanto, se estiver usando uma rede de ponte personalizada ou uma rede de sobreposição, encontrei o abaixo para funcionar melhor:

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

Para estender a resposta de ko-dos, aqui está um alias para listar todos os nomes de contêiner e seus endereços IP:

 alias docker-ips='docker ps | tail -n +2 | while read -aa; do name=${a[$((${#a[@]}-1))]}; echo -ne "$name\t"; docker inspect $name | grep IPAddress | cut -d \" -f 4; done' 

Se você instalou o Docker usando o Docker Toolbox, pode usar o aplicativo Kitematic para obter o endereço IP do contêiner:

  1. Selecione o contêiner
  2. Clique em configurações
  3. Clique na guia Portas.

NOTA!!! para Docker Compose Usage:

Como o Docker Compose cria uma rede isolada para cada cluster, os methods abaixo não funcionam com o docker-compose .


A maneira mais elegante e fácil é definir uma function shell como a resposta mais votada da @ WouterD :

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

O Docker pode gravar IDs de contêiner em um arquivo como os programas Linux:

Rodando com o parâmetro --cidfile=filename , o Docker faz o dump do ID do container para este arquivo.

Docker executa a seção equivalente ao PID

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

Usando o arquivo PID

  1. O contêiner em execução com o parâmetro --cidfile , o conteúdo do arquivo app.cid é como abaixo:

a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909

  1. Você pode usar o conteúdo do arquivo para inspecionar os contêineres do Docker:

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

  2. Extraindo o script Python do Container IP inline:

    $ 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


Mais amigável forma humana

 #!/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  | get-docker-ip.py import json import sys sys.stdout.write(json.load(sys.stdin)[0]['NetworkSettings']['IPAddress']) 

http://networkstatic.net/10-examples-of-how-to-get-docker-container-ip-address/

Aqui há 10 alternativas para obter os endereços IP do contêiner Docker.

Para o Windows 10:

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

Apenas por completude:

Eu realmente gosto da opção –format , mas no começo eu não estava ciente dessa opção então usei uma simples linha de Python para obter o mesmo resultado:

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

Para obter o endereço IP e a porta do host de um contêiner:

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

Saída:

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

Combinando respostas anteriores com a localização do ID do contêiner com base no nome da imagem do Docker.

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

Para aqueles que vieram do Google para encontrar a solução para a execução de comandos do terminal (não por script), o jid (um utilitário de drill-down JSON interativo com autocomplete e sugestão) permite que você obtenha a mesma coisa com menos digitação.

 docker inspect $CID | jid 

Digite guia .net e você verá o seguinte:

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

Digite a aba .IPA e você verá o seguinte:

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

Usar:

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

Para contêineres do Windows, use

 docker exec  ipconfig 

onde é o nome ou o id do contêiner.

Você pode usar o docker ps para encontrar o id do container.

Se você esqueceu o ID do contêiner ou não deseja manipular com comandos do shell, é melhor usar a interface do usuário como o 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 

Lá você pode encontrar todas as informações sobre o contêiner e IP.

Inspecionar não funcionou para mim. Talvez como eu estava usando -net host e alguns namespaces.

Enfim, eu achei isso para funcionar bem:

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

Eu tive que extrair o endereço IP do contêiner docker pelo nome do contêiner docker para uso adicional em scripts de implantação. Para este propósito eu escrevi o seguinte comando 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\}' 

Suponha que possa ser útil colocá-lo em um script bash, que esperaria que my_container_name fosse um argumento …

 docker inspect  | grep -i ip 

Por exemplo:

 docker inspect 2b0c4b617a8c | grep -i ip