Assign static IP to Docker container

I’m now trying to assign a static IP 172.17.0.1 when a Docker container be started up.

I use port 2122 as the ssh port of this container so that I let this container listen port 2122.

  • Docker seems to ignore DOCKER_HOST and other vars set from `eval $(docker-machine env)`
  • pass cookie from http response via nginx proxy
  • How to access mysql outside my kubernetes cluster?
  • Docker volume binding: Base image vs derivative image
  • Can’t push to docker hub (authentication required)
  • execSync compilation failed with npm 3
  • sudo docker run -i -t -p 2122:2122 ubuntu
    

    This command will run a Docker container with a random IP like 172.17.0.5, but I need to assign a specific IP to the container.

    The following shell script is what I reference Docker documentation in advanced network settings.

    pid=$(sudo docker inspect -f '{{.State.Pid}}' <container_name> 2>/dev/null)
    sudo rm -rf /var/run/netns/*
    sudo ln -s /proc/$pid/ns/net /var/run/netns/$pid
    sudo ip link add A type veth peer name B
    sudo brctl addif docker0 A
    sudo ip link set A up
    sudo ip link set B netns $pid
    sudo ip netns exec $pid ip link set eth0 down
    sudo ip netns exec $pid ip link delete eth0
    sudo ip netns exec $pid ip link set dev B name eth0
    sudo ip netns exec $pid ip link set eth0 address 12:34:56:78:9a:bc
    sudo ip netns exec $pid ip link set eth0 down
    sudo ip netns exec $pid ip link set eth0 up
    sudo ip netns exec $pid ip addr add 172.17.0.1/16 dev eth0
    sudo ip netns exec $pid ip route add default via 172.17.42.1
    

    This shell script will assign a static IP 172.17.0.1 and link to the world fine. But whenever I try to ssh to this container from my local, it didn’t work. What’s the problem possibly I met?

  • Running xterm in docker without X-server on host machine
  • Error: image orgsync/java8 not found
  • Keep container alive and linked using docker-compose
  • how to notify error for `restart: on-failure` in docker-compose?
  • Docker best practice on base images and host os
  • Docker and apache2, remove port from url
  • 6 Solutions collect form web for “Assign static IP to Docker container”

    Easy with Docker version 1.10.1, build 9e83765.

    First you need to create you own docker network (mynet123)

    docker network create --subnet=172.18.0.0/16 mynet123
    

    than simply run the image (I’ll take ubuntu as example)

    docker run --net mynet123 --ip 172.18.0.22 -it ubuntu bash
    

    then in ubuntu shell

    ip addr
    

    Additionally you could use

    • --hostname to specify a hostname
    • --add-host to add more entries to /etc/hosts

    Docs (and why you need to create a network) at https://docs.docker.com/engine/reference/commandline/network_create/

    Not a direct answer but it could help.

    I run most of my dockerized services tied to own static ips using the next approach:

    1. I create ip aliases for all services on docker host
    2. Then I run each service redirecting ports from this ip into container so each service have own static ip which could be used by external users and other containers.

    Sample:

    docker run --name dns --restart=always -d -p 172.16.177.20:53:53/udp dns
    docker run --name registry --restart=always -d -p 172.16.177.12:80:5000 registry
    docker run --name cache --restart=always -d -p 172.16.177.13:80:3142 -v /data/cache:/var/cache/apt-cacher-ng cache
    docker run --name mirror --restart=always -d -p 172.16.177.19:80:80 -v /data/mirror:/usr/share/nginx/html:ro mirror
    ...
    

    For docker-compose you can use following docker-compose.yml

    version: '2'
    services:
      nginx:
        image: nginx
        container_name: nginx-container
        networks:
          static-network:
            ipv4_address: 172.20.128.2
    networks:
      static-network:
        ipam:
          config:
            - subnet: 172.20.0.0/16
              ip_range: 172.28.5.0/24
    

    from host you can test using:

    docker-compose up -d
    curl 172.20.128.2
    

    Modern docker-compose will automatically create containers with static ip for you.

    To find static ips of all containers in your docker-compose in a single line use:

    for s in `docker-compose ps -q`; do echo ip of `docker inspect -f "{{.Name}}" $s` is `docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $s`; done
    

    If you want to automate, you can use something like this example gist

    I stumbled upon this problem during attempt to dockerise Avahi which needs to be aware of its public IP to function properly. Assigning static IP to the container is tricky due to lack of support for static IP assignment in Docker.

    This article describes technique how to assign static IP to the container on Debian:

    1. Docker service should be started with DOCKER_OPTS="--bridge=br0 --ip-masq=false --iptables=false". I assume that br0 bridge is already configured.

    2. Container should be started with --cap-add=NET_ADMIN --net=bridge

    3. Inside container pre-up ip addr flush dev eth0 in /etc/network/interfaces can be used to dismiss IP address assigned by Docker as in following example:


    auto lo
    iface lo inet loopback
    
    auto eth0
    iface eth0 inet static
        pre-up ip addr flush dev eth0
        address 192.168.0.249
        netmask 255.255.255.0
        gateway 192.168.0.1
    
    1. Container’s entry script should begin with /etc/init.d/networking start. Also entry script needs to edit or populate /etc/hosts file in order to remove references to Docker-assigned IP.

    You can set the IP while running it.

    docker run --cap-add=NET_ADMIN -dit imagename /bin/sh -c "/sbin/ip addr add 172.17.0.12 dev eth0; bash"
    

    See my example at https://github.com/RvdGijp/mariadb-10.1-galera

    You can access other containers’ service by their name(ping apachewill get the ip or curl http://apache would access the http service) And this can be a alternative of a static ip.

    Docker will be the best open platform for developers and sysadmins to build, ship, and run distributed applications.