web-dev-qa-db-fra.com

Comment ajouter des utilisateurs initiaux lors du démarrage d'un conteneur RabbitMQ Docker?

Actuellement, je commence le conteneur RabbitMQ Docker en utilisant l’image par défaut RabbitMQ de DockerHub . En utilisant les commandes suivantes.

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

J'ai besoin de fournir aux utilisateurs par défaut/et aux hôtes virtuels lorsque l'image est démarrée pour la première fois. Par exemple, pour créer un "utilisateur test" par défaut.

Actuellement, je dois le faire manuellement en utilisant le plugin de gestion et en ajoutant les utilisateurs/hôtes virtuels via l'interface utilisateur Web. Existe-t-il un moyen de fournir les paramètres par défaut lors du démarrage de l’image RabbitMQ?

dockerrabbitmq
30
Marco

Vous pouvez créer un fichier Docker simple qui étend les fonctionnalités de l'image de base et crée un utilisateur par défaut . Le fichier Docker dont vous avez besoin est le suivant:

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

Et l'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 $@

Ce script initialise et expose également l'administrateur Web RabbitMQ sur le port 15672.

35
george.yord

Je suis arrivé avec une solution qui répond à mes besoins, la laissant ici au cas où quelqu'un d'autre en aurait besoin.

Résumé

L'idée est de prendre un conteneur rabbitmq standard avec le plug-in de gestion activé et de l'utiliser pour créer la configuration requise, puis de l'exporter et de l'utiliser pour démarrer de nouveaux conteneurs. La solution ci-dessous crée une image de menu fixe dérivée, mais elle fonctionne également pour monter simplement les deux fichiers au moment de l'exécution (par exemple, à l'aide de la composition de menu fixe).

Références

Composants

  • image officielle de rabbitmq, version du plugin de gestion (rabbitmq: management)

  • image personnalisée basée sur celle d'origine, avec ce fichier Docker (en utilisant la version 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 indique simplement à rabbitmq de charger les définitions à partir du fichier json
  • definitions.json contient les utilisateurs, les hôtes virtuels, etc., et peut être généré par la fonction d'exportation de l'interface Web de gestion.

rabbitmq.config exemple:

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

definitions.json exemple:

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

Version alternave

La création d'une nouvelle image de menu fixe ne constitue qu'une solution et fonctionne mieux lorsque la portabilité est essentielle, car elle évite d'inclure la gestion de fichiers basée sur l'hôte dans l'image.

Dans certaines situations, il peut être préférable d’utiliser l’image officielle et de fournir des fichiers de configuration du stockage local à l’hôte.

Les fichiers rabbitmq.config et definitions.json sont générés de la même manière, puis monté à l'exécution.

Remarques:

  • Je suppose qu'ils ont été placés dans/etc/so/pour les besoins de ces exemples
  • les fichiers doivent être soit lisibles par tout le monde, soit possédés par l'utilisateur ou le groupe rabbitmq (l'identifiant numérique à l'intérieur du conteneur de menu fixe est 999), ceci doit être géré par l'administrateur système de l'hôte.

docker run exemple:

    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

docker compose exemple:

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

J'aimerais ajouter que la réponse de Sudo m'a beaucoup aidé. Mais qu'il manquait encore une commande à ajouter au fichier Docker.

Les fichiers rabbitmq.config et definitions.json doivent appartenir à l'utilisateur et au groupe rabbitmq. Donc, après avoir ajouté les fichiers, exécutez chown.

Le fichier Dockerfile complet dans mon cas était le suivant:

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

Le contenu du fichier rabbitmq.config est une fusion de la configuration par défaut de l'image et du chargement des définitions ajoutées:

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

        ]}
    ]}
].

Le fichier de définitions peut être exporté à partir de l'interface de gestion dans l'onglet Aperçu.

Donc, vous devez d’abord créer un conteneur rabbitmq «vide» normal. Définissez ce que vous voulez comme utilisateurs, échanges et files d'attente. Ensuite, entrez dans l'interface de gestion, exportez les définitions et créez votre propre image en utilisant le fichier comme décrit ci-dessus.

Télécharger les définitions est le moyen le plus simple d’obtenir les hachages de mots de passe appropriés dans le fichier de définitions pour vos propres mots de passe. Si vous ne le souhaitez pas, vous devez suivre les instructions indiquées ici ( https://www.rabbitmq.com/passwords.html ) pour générer le hachage correct.

8
Tom P.

La dernière version de l'image RabbitMQ sur Dockerhub intègre une fonctionnalité permettant de changer le nom d'utilisateur/mot de passe par défaut de "invité"/"invité".

Définissez simplement les variables d'environnement "RABBITMQ_DEFAULT_USER" et "RABBITMQ_DEFAULT_PASS" lors du démarrage de l'image.

En tant que commande de menu fixe, vous exécuteriez l'image comme suit:

docker run \
-e RABBITMQ_DEFAULT_USER=test-user \
-e RABBITMQ_DEFAULT_PASS=test-user \
-p 5672:5672 \
rabbitmq
4
AngryUbuntuNerd

Dans mon cas, la solution sleep 5 ci-dessus ne fonctionnait pas car le temps de démarrage de RabbitMQ était beaucoup plus long et imprévisible. Solution d’affichage qui attend que RabbitMQ soit opérationnel:

  • 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
2
Martin

Je devais apporter quelques modifications au script dans la réponse acceptée pour le faire fonctionner en fonction des commentaires ci-dessus.

Dockerfile  

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

init.sh 

#!/bin/sh
( sleep 10 && \
rabbitmqctl add_user $RABBITMQ_USER $RABBITMQ_PASSWORD && \
rabbitmqctl set_user_tags $RABBITMQ_USER administrator && \
rabbitmqctl set_permissions -p / $RABBITMQ_USER  ".*" ".*" ".*" ) & \
rabbitmq-server
0
Fiacc

Voici un exemple d’ajout d’un utilisateur non privilégié 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 

0
user2915097