hub - ¿Cómo agregar usuarios iniciales al iniciar un contenedor RabbitMQ Docker?

imagenes docker

Question

Actualmente estoy iniciando el contenedor RabbitMQ Docker utilizando la imagen predeterminada de RabbitMQ de DockerHub . Usando los siguientes comandos.

docker run --restart=always /
-d /
-e RABBITMQ_NODENAME=rabbitmq /
-v /opt/docker/rabbitmq/data:/var/lib/rabbitmq/mnesia/rabbitmq /
-p 5672:5672 /
-p 15672:15672 /
--name rabbitmq rabbitmq:3-management

Tengo una necesidad donde quiero proporcionar usuarios predeterminados / y hosts virtuales cuando la imagen se inicia por primera vez. Por ejemplo, para crear un ''usuario de prueba'' predeterminado.

Actualmente tengo que hacerlo manualmente utilizando el complemento de administración y agregando los usuarios / hosts virtuales a través de la interfaz de usuario web. ¿Hay alguna forma en que pueda proporcionar la configuración predeterminada al iniciar la imagen RabbitMQ?

Answer 1

Aquí hay un ejemplo de cómo agrego un usuario no privilegiado gg RUN useradd -d /home/gg -m -s /bin/bash gg RUN echo gg:gg | chpasswd RUN echo ''gg ALL=(ALL) NOPASSWD:ALL'' >> /etc/sudoers.d/gg RUN chmod 0440 /etc/sudoers.d/gg RUN useradd -d /home/gg -m -s /bin/bash gg RUN echo gg:gg | chpasswd RUN echo ''gg ALL=(ALL) NOPASSWD:ALL'' >> /etc/sudoers.d/gg RUN chmod 0440 /etc/sudoers.d/gg

Answer 2

En mi caso, sleep 5 solución sleep 5 anterior no funcionó porque el tiempo de inicio de RabbitMQ fue mucho más largo y no fue predecible. Solución de publicación que espera hasta que RabbitMQ esté en funcionamiento:

• Dockerfile

  FROM rabbitmq:3-management
  ADD init.sh /
  ADD config_rabbit.sh /
  RUN chmod +x /init.sh /config_rabbit.sh
  ENTRYPOINT ["/init.sh"]

• init.sh

  #!/bin/bash
  
  # Launch config script in background
  # Note there is no RabbitMQ Docker image support for executing commands after server (PID 1) is running (something like "ADD schema.sql /docker-entrypoint-initdb.d" in MySql image), so we are using this trick
  /config_rabbit.sh &
  
  # Launch
  /docker-entrypoint.sh rabbitmq-server

• config_rabbit.sh

  #!/bin/bash
  
  # This script needs to be executed just once
  if [ -f /$0.completed ] ; then
    echo "$0 `date` /$0.completed found, skipping run"
    exit 0
  fi
  
  # Wait for RabbitMQ startup
  for (( ; ; )) ; do
    sleep 5
    rabbitmqctl -q node_health_check > /dev/null 2>&1
    if [ $? -eq 0 ] ; then
      echo "$0 `date` rabbitmq is now running"
      break
    else
      echo "$0 `date` waiting for rabbitmq startup"
    fi
  done
  
  # Execute RabbitMQ config commands here
  
  # Create user
  rabbitmqctl add_user USER PASSWORD
  rabbitmqctl set_permissions -p / USER ".*" ".*" ".*"
  echo "$0 `date` user USER created"
  
  # Create queue
  rabbitmqadmin declare queue name=QUEUE durable=true
  echo "$0 `date` queues created"
  
  # Create mark so script is not ran again
  touch /$0.completed

Answer 3

La versión más reciente de la imagen RabbitMQ en Dockerhub tiene una funcionalidad incorporada para cambiar el nombre de usuario / contraseña predeterminado de "guest" / "guest" a otra cosa.

Simplemente configure las variables de entorno "RABBITMQ_DEFAULT_USER" y "RABBITMQ_DEFAULT_PASS" al iniciar la imagen.

Como comando docker, ejecutaría la imagen de esta manera:

FROM rabbitmq
# rabbitmqctl command requires to start the rabbitmq server 
RUN service rabbitmq-server start
RUN /usr/lib/rabbitmq/bin/rabbitmqctl add_user test-user mypassword
RUN /usr/lib/rabbitmq/bin/rabbitmqctl add_vhost myvhost 
RUN /usr/lib/rabbitmq/bin/rabbitmqctl set_permissions -p /myvhost test-user ".*" ".*" ".*"

Answer 4

Llegó con una solución que se adapta a mis necesidades, dejándola aquí en caso de que alguien más la necesite.

Resumen

La idea es tomar un contenedor de conejo estándar con el complemento de administración habilitado y usarlo para crear la configuración requerida, luego exportarlo y usarlo para iniciar nuevos contenedores. La solución a continuación crea una imagen derivada de la ventana acoplable, pero también funciona para simplemente montar los dos archivos en tiempo de ejecución (por ejemplo, utilizando la redacción de la ventana acoplable).

Referencias

• la información que empecé
• Ejemplo completo de rabbitmq.config

Componentes

• Imagen oficial de rabbitmq, versión del plugin de administración ( rabbitmq: management )

• Imagen personalizada basada en la original, con este Dockerfile (usando la versión 3.6.6):

  FROM rabbitmq:3.6.6-management
  ADD rabbitmq.config /etc/rabbitmq/
  ADD definitions.json /etc/rabbitmq/
  RUN chown rabbitmq:rabbitmq /etc/rabbitmq/rabbitmq.config /etc/rabbitmq/definitions.json
  CMD ["rabbitmq-server"]

• rabbitmq.config simplemente le dice a rabbitmq que cargue las definiciones del archivo json
• definition.json contiene los usuarios, vhosts, etc. y puede ser generado por la función de exportación de la interfaz web de administración

Ejemplo de rabbitmq.config :

[
  {rabbit, [
    {loopback_users, []}
  ]},
  {rabbitmq_management, [
    {load_definitions, "/etc/rabbitmq/definitions.json"}
  ]}
].

Definiciones.json ejemplo:

{
 "rabbit_version": "3.6.6",
 "users": [
  {
   "name": "user1",
   "password_hash": "pass1",
   "hashing_algorithm": "rabbit_password_hashing_sha256",
   "tags": ""
  },
  {
   "name": "adminuser",
   "password_hash": "adminpass",
   "hashing_algorithm": "rabbit_password_hashing_sha256",
   "tags": "administrator"
  }
 ],
 "vhosts": [
  {
   "name": "//vhost1"
  },
  {
   "name": "//vhost2"
  }
 ],
 "permissions": [
  {
   "user": "user1",
   "vhost": "//vhost1",
   "configure": ".*",
   "write": ".*",
   "read": ".*"
  }
 ],
 "parameters": [],
 "policies": [],
 "queues": [],
 "exchanges": [],
 "bindings": []
}

Versión alternave

Derivar una nueva imagen de la ventana acoplable es solo una solución y funciona mejor cuando la portabilidad es clave, ya que evita incluir la administración de archivos basada en el host en la imagen.

En algunas situaciones, es preferible utilizar la imagen oficial y proporcionar archivos de configuración desde el almacenamiento local al host.

Los archivos rabbitmq.config y preferences.json se producen de la misma manera, y luego se montan en tiempo de ejecución.

Notas:

• Supongo que se han colocado en / etc / so / por el bien de estos ejemplos
• los archivos deben ser legibles a nivel mundial o ser propiedad del usuario o grupo de rabbitmq (la identificación numérica dentro del contenedor de la ventana acoplable es 999), esto debe ser manejado por el administrador del sistema del host

Ejemplo de ejecución de la ventana acoplable :

    docker run --rm -it /
        -v /etc/so/rabbitmq.config:/etc/rabbitmq/rabbitmq.config:ro /
        -v /etc/so/definitions.json:/etc/rabbitmq/definitions.json:ro /
        rabbitmq:3.6-management

Ejemplo de composición de la ventana acoplable :

    version: ''2.1''
    services:
        rabbitmq:
            image: "rabbitmq:3.6-management"
            ports:
                - 5672:5672
                - 15672:15672
            volumes:
                - /etc/so/rabbitmq.config:/etc/rabbitmq/rabbitmq.config:ro
                - /etc/so/definitions.json:/etc/rabbitmq/definitions.json:ro

Answer 5

Me gustaría añadir que la respuesta de sudo me ayudó mucho. Pero que aún faltaba un comando para agregarse al Dockerfile.

El archivo rabbitmq.config y preferences.json debe ser propiedad del grupo y usuario de rabbitmq. Así que después de agregar los archivos ejecute chown.

El Dockerfile completo en mi caso fue el siguiente:

FROM rabbitmq:3-management-alpine
ADD definitions.json /etc/rabbitmq/
ADD rabbitmq.config /etc/rabbitmq/
RUN chown rabbitmq:rabbitmq /etc/rabbitmq/rabbitmq.config /etc/rabbitmq/definitions.json

EXPOSE 4369 5671 5672 15671 15672 25672

CMD ["rabbitmq-server"]

El archivo rabbitmq.config tiene el siguiente contenido como una combinación de la configuración de la imagen predeterminada y la carga de las definiciones agregadas:

[
    { rabbit, [
        {loopback_users, []},
        { tcp_listeners, [ 5672 ]},
        { ssl_listeners, [ ]},
        { hipe_compile, false } 
    ]},
    { rabbitmq_management, [
        { load_definitions, "/etc/rabbitmq/definitions.json"},
        { listeners, [
            { port, 15672 },
            { ssl, false } 

        ]}
    ]}
].

El archivo de definiciones se puede exportar desde la interfaz de administración en la pestaña de vista general.

Así que primero crearías un contenedor normal de conejo ''vacío''. Define los usuarios, intercambios y colas que desee. Luego ingrese a la interfaz de administración, exporte las definiciones y cree su propia imagen usando el archivo como se describe anteriormente.

Descargar las definiciones es la forma más fácil de obtener los hashes de contraseña correctos en el archivo de definiciones para sus propias contraseñas. Si no desea hacer eso, debe seguir las instrucciones que se indican aquí ( https://www.rabbitmq.com/passwords.html ) para generar los hashes correctos.

Answer 6

Puede crear un Dockerfile simple que amplíe la funcionalidad de la imagen básica y cree un usuario predeterminado. El archivo Docker que necesita es el siguiente:

FROM rabbitmq

# Define environment variables.
ENV RABBITMQ_USER user
ENV RABBITMQ_PASSWORD user

ADD init.sh /init.sh
EXPOSE 15672

# Define default command
CMD ["/init.sh"]

Y el init.sh:

#!/bin/sh

# Create Rabbitmq user
( sleep 5 ; /
rabbitmqctl add_user $RABBITMQ_USER $RABBITMQ_PASSWORD 2>/dev/null ; /
rabbitmqctl set_user_tags $RABBITMQ_USER administrator ; /
rabbitmqctl set_permissions -p / $RABBITMQ_USER  ".*" ".*" ".*" ; /
echo "*** User ''$RABBITMQ_USER'' with password ''$RABBITMQ_PASSWORD'' completed. ***" ; /
echo "*** Log in the WebUI at port 15672 (example: http:/localhost:15672) ***") &

# $@ is used to pass arguments to the rabbitmq-server command.
# For example if you use it like this: docker run -d rabbitmq arg1 arg2,
# it will be as you run in the container rabbitmq-server arg1 arg2
rabbitmq-server $@

Esta secuencia de comandos también inicializa y expone el administrador web de RabbitMQ en el puerto 15672.

Answer 7

Puede crear una nueva imagen y usar la línea de comando rabbitmqctl .

Por ejemplo usando este Dockerfile:

sudo docker build -t anImageName .

Y construye la imagen usando

sudo docker build -t anImageName .

No he probado mi respuesta, no puedo usar la ventana acoplable en el trabajo