web-dev-qa-db-fra.com

Comment puis-je me connecter à distance à Docker Swarm?

Est-il possible d'exécuter des commandes sur un cluster swarm docker hébergé dans le cloud à partir de mon Mac local? Si oui comment?

Je veux exécuter une commande telle que suivre l’essaim de docker depuis mon local:

docker create secret my-secret <address to local file>
docker service create --name x --secrets my-secret image
dockerdocker-swarmdocker-swarm-modedocker-secrets
7
Navdeep

Vous pouvez trouver la réponse à la question ici .

Pour ce qui est de la machine ubuntu, il faut définir le fichier daemon.json au chemin /etc/docker avec le contenu suivant:

  {
    "hosts": ["tcp://0.0.0.0:2375", "unix:///var/run/docker.sock"]
  }

La configuration ci-dessus n'est pas sécurisée et ne devrait pas être utilisée si le serveur est hébergé publiquement.

Pour une connexion sécurisée, utilisez la configuration suivante:

{
  "tls": true,
  "tlscert": "/var/docker/server.pem",
  "tlskey": "/var/docker/serverkey.pem",
  "hosts": ["tcp://x.x.x.y:2376", "unix:///var/run/docker.sock"]
}

Les détails pour générer un certificat peuvent être trouvés ici comme mentionné par @BMitch.

7
Navdeep

Pour vous connecter à un nœud de docker distant, vous devez configurer TLS sur l'hôte et le client de docker signés à partir de la même autorité de certification. Veillez à limiter le nombre de clés que vous signez avec cette autorité de certification, car cette dernière est utilisée pour contrôler l'accès à l'hôte de menu fixe.

Docker a documenté les étapes pour configurer une autorité de certification et créer/installer les clés ici: https://docs.docker.com/engine/security/https/

Une fois configuré, vous pouvez vous connecter aux environnements en mode Swarm les plus récents à l'aide des mêmes commandes de menu fixe que celles exécutées localement sur l'hôte de menu fixe en modifiant simplement la valeur de $ DOCKER_Host dans votre shell.

2
BMitch

Une option consiste à fournir un accès direct au démon docker comme suggéré dans les réponses précédentes, mais cela nécessite la configuration de certificats et de clés TLS, ce qui peut être fastidieux et prendre beaucoup de temps. La machine Docker peut automatiser ce processus lorsque la machine Docker a été utilisée pour créer les nœuds.

J'ai eu le même problème, en ce sens que je voulais créer des secrets sur l'essaim sans télécharger le fichier contenant le secret sur le gestionnaire de l'essaim. De plus, je souhaitais pouvoir exécuter le fichier de déploiement de déploiement (par exemple, docker-compose.yml) sans le souci de télécharger en premier le fichier de pile. 

Je voulais pouvoir créer les quelques serveurs dont j'avais besoin, par exemple. DigitalOcean, qui n’utilise pas nécessairement Docker Machine, et peut créer de manière reproductible les secrets et exécuter le stackfile. Dans des environnements tels que DigitalOcean et AWS, un ensemble distinct de certificats TLS n'est pas utilisé, mais la clé ssh de la machine locale est utilisée pour accéder au nœud distant via ssh.

La solution qui a fonctionné pour moi a été d'exécuter les commandes du menu fixe à l'aide de commandes individuelles sur ssh, ce qui me permet de diriger le secret et/ou le fichier de pile à l'aide de stdin.

Pour ce faire, vous devez d’abord créer les droplets DigitalOcean et y installer le menu fixe, éventuellement à partir d’une image ou d’un instantané personnalisé, ou tout simplement d’exécuter les commandes pour installer le menu fixe sur chaque droplet. Ensuite, joignez les droplets dans un essaim: ssh dans celui qui sera le nœud du gestionnaire, tapez docker swarm init (éventuellement avec l'option --advertise-addr s'il existe plusieurs adresses IP sur ce nœud, par exemple, lorsque vous souhaitez conserver le trafic intra-essaim sur le réseau privé) et récupérez la commande rejoindre pour l'essaim. Ensuite, ssh dans chacun des autres nœuds et émettez la commande join, et votre essaim est créé.

Ensuite, exportez la commande ssh dont vous aurez besoin pour exécuter des commandes sur le noeud du gestionnaire, comme

export SSH_CMD='ssh [email protected]'

Maintenant, vous avez deux options. Vous pouvez émettre des commandes individuelles dans le menu fixe, telles que:

$SSH_CMD docker service ls

Vous pouvez créer un secret sur votre essaim sans copier le fichier secret dans le gestionnaire de l'essaim:

$SSH_CMD docker create secret my-secret - < /path/to/local/file
$SSH_CMD docker service create --name x --secrets my-secret image

(Utiliser - pour indiquer que docker create secret doit accepter le secret sur stdin, puis rediriger le fichier vers stdin à l'aide de ssh)

Vous pouvez également créer un script pour pouvoir exécuter de manière reproductible des commandes afin de créer vos secrets et afficher votre pile avec des fichiers secrets et des fichiers de pile uniquement sur votre ordinateur local. Un tel script pourrait être:

$SSH_CMD docker secret create rabbitmq.config.01 - < rabbitmq/rabbitmq.config
$SSH_CMD docker secret create enabled_plugins.01 - < rabbitmq/enabled_plugins
$SSH_CMD docker secret create rmq_cacert.pem.01 - < rabbitmq/cacert.pem
$SSH_CMD docker secret create rmq_cert.pem.01 - < rabbitmq/cert.pem
$SSH_CMD docker secret create rmq_key.pem.01 - < rabbitmq/key.pem
$SSH_CMD docker stack up -c - rabbitmq_stack < rabbitmq.yml

où secrets sont utilisés pour les certificats et les clés, ainsi que pour les fichiers de configuration rabbitmq.config et enabled_plugins, et le fichier de pile est rabbitmq.yml, qui pourrait être:

version: '3.1'
services:
  rabbitmq:
    image: rabbitmq
    secrets:
      - source: rabbitmq.config.01
        target: /etc/rabbitmq/rabbitmq.config
      - source: enabled_plugins.01
        target: /etc/rabbitmq/enabled_plugins
      - source: rmq_cacert.pem.01
        target: /run/secrets/rmq_cacert.pem
      - source: rmq_cert.pem.01
        target: /run/secrets/rmq_cert.pem
      - source: rmq_key.pem.01
        target: /run/secrets/rmq_key.pem
    ports: 
      # stomp, ssl:
      - 61614:61614
      # amqp, ssl:
      - 5671:5671
      # monitoring, ssl:
      - 15671:15671
      # monitoring, non ssl:
      - 15672:15672
  # nginx here is only to show another service in the stackfile
  nginx:
    image: nginx
    ports: 
      - 80:80
secrets:
  rabbitmq.config.01:
    external: true
  rmq_cacert.pem.01:
    external: true
  rmq_cert.pem.01:
    external: true
  rmq_key.pem.01:
    external: true
  enabled_plugins.01:
    external: true

(Ici, le fichier rabbitmq.config configure les ports d’écoute ssh pour stomp, amqp et l’interface de surveillance, et indique à rabbitmq de rechercher les certs et la clé dans/run/secrets. Une autre alternative pour cette image spécifique serait d’utiliser les variables d’environnement fournies par l’image pour pointer vers les fichiers secrets, mais je souhaitais une solution plus générique ne nécessitant pas de configuration dans l’image)

Maintenant, si vous voulez faire apparaître un autre essaim, votre script fonctionnera avec cet essaim une fois que vous aurez défini la variable d'environnement SSH_CMD et vous ne devrez ni configurer TLS ni copier votre fichier secret ou stackfiles dans le système de fichiers essaim.

Donc, cela ne résout pas le problème de la création de l'essaim (dont l'existence était présupposée par votre question), mais une fois créé, l'utilisation d'une variable d'environnement (exportée si vous souhaitez l'utiliser dans des scripts) vous permettra d'utiliser presque exactement les commandes que vous avez énumérées, précédées de cette variable d’environnement.

1
nachbar

Si vous partez de zéro, vous pouvez créer le nœud du gestionnaire à l’aide d’un pilote générique docker-machine . Ensuite, vous pourrez vous connecter à ce moteur de docker à partir de votre ordinateur local à l'aide de la commande docker-machine env.

0
andrey