una subir imagen hub guardar example ejemplos crear contenedor linux ubuntu networking docker network-programming

linux - subir - imagen docker ubuntu



¿Cómo crear una red de superposición de Docker entre varios hosts? (3)

Creo que las opciones que especifique deberían usar cluster-store=consul lugar de cluster-store-consul . Intente reiniciar y reiniciar el motor y enjambre y comprobar si funciona. Después de eso debería de funcionar. El documento de introducción explica claramente cómo configurar las redes de superposición de Docker usando cónsul como respaldo del almacén de datos.

DOCKER_OPTS="-D --cluster-store=consul://192.168.0.18:8500 --cluster-advertise=192.168.0.18:2375" DOCKER_OPTS="-D --cluster-store=consul://192.168.0.18:8500 --cluster-advertise=192.168.0.36:2375"

He intentado crear una red superpuesta entre dos hosts sin éxito. Sigo recibiendo el mensaje de error:

mavungu@mavungu-Aspire-5250:~$ sudo docker -H tcp://192.168.0.18:2380 network create -d overlay myapp Error response from daemon: 500 Internal Server Error: failed to parse pool request for address space "GlobalDefault" pool "" subpool "": cannot find address space GlobalDefault (most likely the backing datastore is not configured) mavungu@mavungu-Aspire-5250:~$ sudo docker network create -d overlay myapp [sudo] password for mavungu: Error response from daemon: failed to parse pool request for address space "GlobalDefault" pool "" subpool "": cannot find address space GlobalDefault (most likely the backing datastore is not configured)

Detalles de mi entorno:

mavungu@mavungu-Aspire-5250:~$ sudo docker info Containers: 1 Images: 364 Server Version: 1.9.1 Storage Driver: aufs Root Dir: /var/lib/docker/aufs Backing Filesystem: extfs Dirs: 368 Dirperm1 Supported: true Execution Driver: native-0.2 Logging Driver: json-file Kernel Version: 3.19.0-26-generic Operating System: Ubuntu 15.04 CPUs: 2 Total Memory: 3.593 GiB Name: mavungu-Aspire-5250 Registry: https://index.docker.io/v1/ WARNING: No swap limit support

Tengo un grupo de enjambres que funciona bien con cónsul como mecanismo de descubrimiento:

mavungu@mavungu-Aspire-5250:~$ sudo docker -H tcp://192.168.0.18:2380 info Containers: 4 Images: 51 Role: primary Strategy: spread Filters: health, port, dependency, affinity, constraint Nodes: 2 mavungu-Aspire-5250: 192.168.0.36:2375 └ Containers: 1 └ Reserved CPUs: 0 / 2 └ Reserved Memory: 0 B / 3.773 GiB └ Labels: executiondriver=native-0.2, kernelversion=3.19.0-26-generic, operatingsystem=Ubuntu 15.04, storagedriver=aufs mavungu-HP-Pavilion-15-Notebook-PC: 192.168.0.18:2375 └ Containers: 3 └ Reserved CPUs: 0 / 4 └ Reserved Memory: 0 B / 3.942 GiB └ Labels: executiondriver=native-0.2, kernelversion=4.2.0-19-generic, operatingsystem=Ubuntu 15.10, storagedriver=aufs CPUs: 6 Total Memory: 7.715 GiB Name: bb47f4e57436

Mi cónsul está disponible en 192.168.0.18:8500 y funciona bien con el clúster de enjambre.

Me gustaría poder crear una red superpuesta en los dos hosts. He configurado los motores Docker en ambos hosts con esta configuración adicional:

DOCKER_OPTS="-D --cluster-store-consul://192.168.0.18:8500 --cluster-advertise=192.168.0.18:0" DOCKER_OPTS="-D --cluster-store-consul://192.168.0.18:8500 --cluster-advertise=192.168.0.36:0"

Tuve que detener y reiniciar los motores y restablecer el clúster de enjambre ... Después de no poder crear la red superpuesta, cambié la configuración de --cluster-advertising a esto:

DOCKER_OPTS="-D --cluster-store-consul://192.168.0.18:8500 --cluster-advertise=192.168.0.18:2375" DOCKER_OPTS="-D --cluster-store-consul://192.168.0.18:8500 --cluster-advertise=192.168.0.36:2375"

Pero aún así no funcionó. No estoy seguro de qué ip: puerto debe configurarse para --cluster-advertise= . Los documentos, las discusiones y los tutoriales no son claros sobre esta publicidad.

Hay algo que me estoy equivocando aquí. Por favor ayuda.

Cuando ejecute el comando docker run , asegúrese de agregar --net myapp . Aquí hay un tutorial completo paso a paso ( versión en línea ):

Cómo implementar enjambre en un clúster con red de múltiples hosts

TL; DR: tutorial paso a paso para implementar una red de hosts múltiples usando Swarm . Quería poner en línea este tutorial lo antes posible, así que ni siquiera me tomé el tiempo para la presentación. El archivo de descuento está disponible en el github de mi sitio web . Siéntase libre de adaptarlo y compartirlo, está licenciado bajo una licencia internacional Creative Commons Attribution 4.0 .

Prerrequisitos

Ambiente

Swarm administrador de Swarm y el maestro cónsul se ejecutarán en la máquina llamada bugs20. Otros nodos, bugs19, bugs18, bugs17 y bugs16, serán agentes de Swarm y miembros del cónsul .

Antes que empecemos

Consul se usa para la red de múltiples hosts, se puede usar cualquier otro almacén de valores clave; tenga en cuenta que el motor admite Consul Etcd y ZooKeeper . El token (o archivo estático) se utiliza para el descubrimiento de agentes de Swarm . Los tokens usan la API REST, se prefiere un archivo estático.

La red

La red tiene un rango de 192.168.196.0/25. El host llamado bugsN tiene la dirección IP 192.168.196.N.

El demonio docker

Todos los nodos están ejecutando Docker Daemon de la siguiente manera:

/usr/bin/docker daemon -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --cluster-advertise eth0:2375 --cluster-store consul://127.0.0.1:8500 Detalles de opciones:

-H tcp://0.0.0.0:2375

Vincula el daemon a una interfaz para permitir ser parte del clúster de Swarm . Obviamente, se puede especificar una dirección IP, es una mejor solución si tiene varias NIC.

--cluster-advertise eth0:2375

Define la interfaz y el puerto del docker demonio que debe usar para anunciarse.

--cluster-store consul://127.0.0.1:8500

Define la URL del backend de almacenamiento distribuido. En nuestro caso utilizamos cónsul , aunque existen otras herramientas de descubrimiento que se pueden usar, si desea tomar una decisión, debería estar interesado en leer esta comparación de descubrimiento de servicios .

A medida que se distribuye el cónsul , la URL puede ser local (recuerde, los agentes de Swarm también son miembros del cónsul ) y esto es más flexible ya que no tiene que especificar la dirección IP del maestro de cónsul y ser seleccionado después de que se haya iniciado el demonio de Docker .

Los alias utilizados

En los siguientes comandos se utilizan estos dos alias:

alias ldocker=''docker -H tcp://0.0.0.0:2375'' alias swarm-docker=''docker -H tcp://0.0.0.0:5732'' #used only on the swarm manager

Asegúrese de tener la ruta del binario cónsul en su $PATH . Una vez que esté en el directorio, simplemente escriba export PATH=$PATH:$(pwd) hará el truco.

También se supone que la variable $IP se ha configurado y exportado correctamente. Se puede hacer, gracias a .bashrc o .zshrc o de lo contrario, con algo como esto:

export IP=$(ifconfig |grep "192.168.196."|cut -d ":" -f 2|cut -d " " -f 1)

Cónsul

Comencemos a implementar todos los miembros del cónsul y master según sea necesario.

Cónsul maestro (bugs20)

consul agent -server -bootstrap-expect 1 -data-dir /tmp/consul -node=master -bind=$IP -client $IP Detalles de opciones:

agent -server

Inicie el agente cónsul como servidor.

-bootstrap-expect 1

Esperamos un solo maestro.

-node=master20

Este servidor / maestro cónsul se llamará "master20".

-bind=192.168.196.20

Especifica la dirección IP en la que debe vincularse. Opcional si solo tiene una NIC.

-client=192.168.196.20

Especifica la dirección IP de RPC en la que se debe vincular el servidor. Por defecto es localhost. Tenga en cuenta que no estoy seguro acerca de la necesidad de esta opción, y esta fuerza para agregar -rpc-addr=192.168.196.20:8400 para solicitud local, como consul members -rpc-addr=192.168.196.20:8400 o consul join -rpc-addr=192.168.196.20:8400 192.168.196.9 para unirse al miembro del cónsul que tiene la dirección IP 192.168.196.9 .

Miembros del cónsul (errores {16..19})

consul agent -data-dir /tmp/consul -node=$HOSTNAME -bind=192.168.196.N

Se sugiere usar tmux , o similar, con la opción :setw synchronize-panes on este comando: consul -d agent -data-dir /tmp/consul -node=$HOST -bind=$IP inicia todos los miembros del cónsul .

Únete a los miembros del cónsul

consul join -rpc-addr=192.168.196.20:8400 192.168.196.16 consul join -rpc-addr=192.168.196.20:8400 192.168.196.17 consul join -rpc-addr=192.168.196.20:8400 192.168.196.18 consul join -rpc-addr=192.168.196.20:8400 192.168.196.19

También se puede usar un comando de una línea. Si está usando zsh, entonces el consul join -rpc-addr=192.168.196.20:8400 192.168.196.{16..19} es suficiente, o un bucle foor: for i in $(seq 16 1 19); do consul join -rpc-addr=192.168.196.20:8400 192.168.196.$i;done for i in $(seq 16 1 19); do consul join -rpc-addr=192.168.196.20:8400 192.168.196.$i;done . Puede verificar si sus miembros son parte de su despliegue de cónsul con el comando:

consul members -rpc-addr=192.168.196.20:8400 Node Address Status Type Build Protocol DC master20 192.168.196.20:8301 alive server 0.5.2 2 dc1 bugs19 192.168.196.19:8301 alive client 0.5.2 2 dc1 bugs18 192.168.196.18:8301 alive client 0.5.2 2 dc1 bugs17 192.168.196.17:8301 alive client 0.5.2 2 dc1 bugs16 192.168.196.16:8301 alive client 0.5.2 2 dc1

Los miembros del cónsul y el maestro están desplegados y trabajando. El foco ahora estará en el acoplador y Swarm .

Enjambre

A continuación, se detalla la creación del administrador de enjambres y el descubrimiento de miembros de enjambres utilizando dos métodos diferentes: token y archivo estático. Los tokens usan un servicio de descubrimiento alojado con Docker Hub, mientras que el archivo estático es solo local y no usa la red (ni ningún servidor). Se debe preferir la solución de archivos estáticos (y en realidad es más fácil).

[archivo estático] Inicie el administrador de enjambre mientras se une a los miembros de enjambre

Cree un archivo llamado /tmp/cluster.disco con el contenido swarm_agent_ip:2375 .

cat /tmp/cluster.disco 192.168.196.16:2375 192.168.196.17:2375 192.168.196.18:2375 192.168.196.19:2375

Luego, simplemente inicie el administrador de enjambre de la siguiente manera:

ldocker run -v /tmp/cluster.disco:/tmp/cluster.disco -d -p 5732:2375 swarm manage file:///tmp/cluster.disco

Y tu estas listo !

[token] Crea e inicia el administrador de enjambres

En el maestro de enjambre (bugs20), crea un enjambre:

ldocker run --rm swarm create > swarm_id

Esto crea un enjambre y guarda la identificación del token en el archivo swarm_id del directorio actual. Una vez creado, el administrador de enjambre debe ejecutarse como un demonio:

ldocker run -d -p 5732:2375 swarm manage token://`cat swarm_id`

Para verificar si está iniciado, puede ejecutar:

ldocker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES d28238445532 swarm "/swarm manage token:" 5 seconds ago Up 4 seconds 0.0.0.0:5732->2375/tcp cranky_liskov

[ficha] Únete a los miembros del enjambre en el grupo de enjambres

Entonces el administrador de enjambre necesitará un agente de enjambre para unirse.

ldocker run swarm join --addr=192.168.196.16:2375 token://`cat swarm_id` ldocker run swarm join --addr=192.168.196.17:2375 token://`cat swarm_id` ldocker run swarm join --addr=192.168.196.18:2375 token://`cat swarm_id` ldocker run swarm join --addr=192.168.196.19:2375 token://`cat swarm_id`

std [in | out] estará ocupado, estos comandos deben ejecutarse en diferentes terminales. Agregar -d antes de la join debería resolver esto y permite que se use un bucle for para las uniones.

Después de la unión de los miembros del enjambre:

auzias@bugs20:~$ ldocker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES d1de6e4ee3fc swarm "/swarm join --addr=1" 5 seconds ago Up 4 seconds 2375/tcp fervent_lichterman 338572b87ce9 swarm "/swarm join --addr=1" 6 seconds ago Up 4 seconds 2375/tcp mad_ramanujan 7083e4d6c7ea swarm "/swarm join --addr=1" 7 seconds ago Up 5 seconds 2375/tcp naughty_sammet 0c5abc6075da swarm "/swarm join --addr=1" 8 seconds ago Up 6 seconds 2375/tcp gloomy_cray ab746399f106 swarm "/swarm manage token:" 25 seconds ago Up 23 seconds 0.0.0.0:5732->2375/tcp ecstatic_shockley

Después del descubrimiento de los miembros del enjambre.

Para verificar si los miembros están bien descubiertos, puede ejecutar la información de swarm-docker info :

auzias@bugs20:~$ swarm-docker info Containers: 4 Images: 4 Role: primary Strategy: spread Filters: health, port, dependency, affinity, constraint Nodes: 4 bugs16: 192.168.196.16:2375 └ Containers: 0 └ Reserved CPUs: 0 / 12 └ Reserved Memory: 0 B / 49.62 GiB └ Labels: executiondriver=native-0.2, kernelversion=3.16.0-4-amd64, operatingsystem=Debian GNU/Linux 8 (jessie), storagedriver=aufs bugs17: 192.168.196.17:2375 └ Containers: 0 └ Reserved CPUs: 0 / 12 └ Reserved Memory: 0 B / 49.62 GiB └ Labels: executiondriver=native-0.2, kernelversion=3.16.0-4-amd64, operatingsystem=Debian GNU/Linux 8 (jessie), storagedriver=aufs bugs18: 192.168.196.18:2375 └ Containers: 0 └ Reserved CPUs: 0 / 12 └ Reserved Memory: 0 B / 49.62 GiB └ Labels: executiondriver=native-0.2, kernelversion=3.16.0-4-amd64, operatingsystem=Debian GNU/Linux 8 (jessie), storagedriver=aufs bugs19: 192.168.196.19:2375 └ Containers: 4 └ Reserved CPUs: 0 / 12 └ Reserved Memory: 0 B / 49.62 GiB └ Labels: executiondriver=native-0.2, kernelversion=3.16.0-4-amd64, operatingsystem=Debian GNU/Linux 8 (jessie), storagedriver=aufs CPUs: 48 Total Memory: 198.5 GiB Name: ab746399f106

En este punto, se despliega el enjambre y todos los contenedores ejecutados se ejecutarán en diferentes nodos. Al ejecutar varios:

auzias@bugs20:~$ swarm-docker run --rm -it ubuntu bash

y luego a:

auzias@bugs20:~$ swarm-docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 45b19d76d38e ubuntu "bash" 6 seconds ago Up 5 seconds bugs18/boring_mccarthy 53e87693606e ubuntu "bash" 6 seconds ago Up 5 seconds bugs16/amazing_colden b18081f26a35 ubuntu "bash" 6 seconds ago Up 4 seconds bugs17/small_newton f582d4af4444 ubuntu "bash" 7 seconds ago Up 4 seconds bugs18/naughty_banach b3d689d749f9 ubuntu "bash" 7 seconds ago Up 4 seconds bugs17/pensive_keller f9e86f609ffa ubuntu "bash" 7 seconds ago Up 5 seconds bugs16/pensive_cray b53a46c01783 ubuntu "bash" 7 seconds ago Up 4 seconds bugs18/reverent_ritchie 78896a73191b ubuntu "bash" 7 seconds ago Up 5 seconds bugs17/gloomy_bell a991d887a894 ubuntu "bash" 7 seconds ago Up 5 seconds bugs16/angry_swanson a43122662e92 ubuntu "bash" 7 seconds ago Up 5 seconds bugs17/pensive_kowalevski 68d874bc19f9 ubuntu "bash" 7 seconds ago Up 5 seconds bugs16/modest_payne e79b3307f6e6 ubuntu "bash" 7 seconds ago Up 5 seconds bugs18/stoic_wescoff caac9466d86f ubuntu "bash" 7 seconds ago Up 5 seconds bugs17/goofy_snyder 7748d01d34ee ubuntu "bash" 7 seconds ago Up 5 seconds bugs16/fervent_einstein 99da2a91a925 ubuntu "bash" 7 seconds ago Up 5 seconds bugs18/modest_goodall cd308099faac ubuntu "bash" 7 seconds ago Up 6 seconds bugs19/furious_ritchie

Como se muestra, los contenedores se diseminan sobre errores {16 ... 19}.

Red de múltiples hosts

Se necesita una superposición de red para que todos los contenedores se puedan "conectar" a esta superposición. Para crear esta superposición de red, ejecute:

auzias@bugs20:~$ swarm-docker network create -d overlay net auzias@bugs20:~$ swarm-docker network ls|grep "net" c96760503d06 net overlay

Y voilá !

Una vez que se haya creado esta superposición, agregue --net net al comando swarm-docker run --rm -it ubuntu bash y todos sus contenedores podrán comunicarse de forma nativa como si estuvieran en la misma LAN. La red predeterminada es 10.0.0.0/24.

Habilitación de multidifusión

La superposición predeterminada no admite la multidifusión. Se requiere otro controlador para poder utilizar la multidifusión. El docker plugin weave net no admite multidifusión.

Para usar este controlador, una vez instalado, deberá ejecutar el $weave launch en todos los agentes de Swarm y el administrador de Swarm. Luego, necesitará conectar el tejido juntos, esto se hace ejecutando $weave connect $SWARM_MANAGER_IP . Obviamente no es la dirección IP del administrador de Swarm, pero es más limpio hacerlo (o usar otro nodo que los agentes de Swarm).

En este punto, el clúster de tejido está desplegado, pero no se ha creado ninguna red de tejido. Ejecutando $swarm-docker network create --driver weave weave-net creará la red de weave-net llamada weave-net . Iniciar contenedores con --net weave-net les permitirá compartir la misma LAN y usar multidifusión. Ejemplo de un comando completo para iniciar dichos contenedores es: $swarm-docker run --rm -it --privileged --net=weave-net ubuntu bash .

Para cualquiera que haya venido a esto desde que se lanzó Docker 1.12 , esto ahora es trivialmente fácil: el modo Enjambre está integrado en el motor y no necesita Consul ni ningún otro componente adicional.

Suponiendo que tiene dos hosts con Docker instalado, inicie Swarm en la primera máquina:

> docker swarm init Swarm initialized: current node (6ujd4o5fx1dmav5uvv4khrp33) is now a manager To add a worker to this swarm, run the following command: docker swarm join / --token SWMTKN-1-54xs4bn7qs6su3xjjn7ul5am9z9073by2aqpey56tnccbi93zy-blugim00fuozg6qs289etc / 172.17.0.54:2377

Ese host se convierte en el primer nodo administrador en el enjambre, y escribe el comando que utiliza para unir otros nodos al enjambre: el token secreto y la dirección IP donde el administrador está escuchando.

En el segundo host:

> docker swarm join 172.17.0.54:2377 --token SWMTKN-1-54xs4bn7qs6su3xjjn7ul5am9z9073by2aqpey56tnccbi93zy-blugim00fuozg6qs289etc This node joined a swarm as a worker.

Ahora tiene un enjambre seguro de 2 nodos que tiene descubrimiento de servicio , actualizaciones continuas y escala de servicio .

Cree su red superpuesta en el nodo administrador con:

> docker network create -d overlay my-net d99lmsfzhcb16pdp2k7o9sehv

Y ahora tiene una red de superposición de host múltiple con DNS incorporado, por lo que los servicios pueden resolverse entre sí en función del nombre del servicio.