pour macOS et Windows

Docker v 18.03 et plus (depuis le 21 mars 2018)

utilisez votre adresse IP interne ou connectez-vous au nom DNS spécial host.docker.internal qui se résoudra à l'adresse IP interne utilisée par l'hôte.

prise en charge de Linux en attente https://github.com/docker/for-linux/issues/264

MacOS avec des versions antérieures de Docker

Docker pour Mac v 17.12 à v 18.02

comme ci-dessus, mais utilisez docker.for.mac.host.internal à la place.

Docker pour Mac v 17.06 à v 17.11

comme ci-dessus, mais utilisez docker.for.mac.localhost à la place.

Docker pour Mac 17.05 et en dessous de

pour accéder à la machine hôte à partir du conteneur docker vous devez attacher un alias IP à votre interface réseau. Vous pouvez lier n'importe quelle IP que vous voulez, assurez-vous juste que vous ne l'utilisez à rien d'autre.

sudo ifconfig lo0 alias 123.123.123.123/24

alors assurez-vous que votre serveur est à l'écoute de L'IP mentionnée ci-dessus ou 0.0.0.0 . S'il écoute sur localhost 127.0.0.1 il n'acceptera pas la connexion.

alors il suffit de pointer votre conteneur docker sur cette IP et vous pouvez accéder à la machine hôte!

Pour tester, vous pouvez exécuter quelque chose comme curl -X GET 123.123.123.123:3000 à l'intérieur du conteneur.

l'alias se réinitialisera à chaque redémarrage, donc créez un script de démarrage si nécessaire.

Solution et plus de documentation ici: https://docs.docker.com/docker-for-mac/networking/#use-cases-and-workarounds

je fais un hack similaire à ci-dessus affiche d'obtenir l'adresse IP locale de la carte à un alias de nom (DNS) dans le récipient. Le problème majeur est d'obtenir dynamiquement avec un script simple qui fonctionne à la fois dans Linux et OSX l'adresse IP hôte . J'ai fait ce script qui fonctionne dans les deux environnements (même dans la distribution Linux avec "$LANG" != "en_*" configuré):

ifconfig | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" | grep -v 127.0.0.1 | awk '{ print  }' | cut -f2 -d: | head -n1

ainsi, en utilisant Docker composer, la configuration complète sera:

script de démarrage (docker-run.sh) :

export DOCKERHOST=$(ifconfig | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" | grep -v 127.0.0.1 | awk '{ print  }' | cut -f2 -d: | head -n1)
docker-compose -f docker-compose.yml up

docker-composer.yml :

myapp:
  build: .
  ports:
    - "80:80"
  extra_hosts:
    - "dockerhost:$DOCKERHOST"

puis changer http://localhost en http://dockerhost dans votre code.

pour un guide plus avancé sur la façon de personnaliser le script DOCKERHOST , jetez un oeil à ce post avec une explication de la façon dont il fonctionne.

cela a fonctionné pour moi sur une pile Nginx / PHP-FPM sans toucher à aucun code ou réseau où l'application s'attend juste à être en mesure de se connecter à localhost

monter mysqld.sock de l'hôte à l'intérieur du conteneur.

trouver l'emplacement du mysql.fichier sock sur l'hôte qui exécute mysql:

netstat -ln | awk '/mysql(.*)?\.sock/ { print }'

montez ce fichier à l'endroit prévu dans le docker:

docker run -v /hostpath/to/mysqld.sock:/containerpath/to/mysqld.sock

emplacements possibles de mysqld.sock:

/tmp/mysqld.sock
/var/run/mysqld/mysqld.sock 
/var/lib/mysql/mysql.sock
/Applications/MAMP/tmp/mysql/mysql.sock # if running via MAMP

Solution pour Windows 10

Docker Community Edition 17.06.0-ce-win18 2017-06-28 (stable)

vous pouvez utiliser le nom DNS de l'hôte docker.for.win.localhost , pour résoudre à L'IP interne. (Avertissement de certaines sources mentionnées windows mais il devrait être win )

vue d'ensemble

J'avais besoin d' pour faire quelque chose de similaire, c'est Connecter de mon Docker container à mon localhost, qui exécutait les Azure Storage Emulator et CosmosDB Emulator .

le Azure Storage Emulator par défaut écoute sur 127.0.0.1 , alors que vous pouvez changer L'IP sa limite aussi, je cherchais une solution qui fonctionnerait avec les paramètres par défaut.

cela fonctionne aussi pour la connexion de mon conteneur Docker à SQL Server et IIS , les deux fonctionnant localement sur mon hôte avec les paramètres de port par défaut.

pour ceux qui se trouvent sur Windows, en supposant que vous utilisez le pilote bridge network, vous voudrez lier MySQL spécifiquement à L'adresse ip de l'interface réseau hyper-V.

cela se fait via le fichier de configuration sous le C:\ProgramData\MySQL dossier.

Reliure à 0.0.0.0 ne fonctionnera pas. L'adresse nécessaire est indiqué dans le panneau de configuration, et dans mon cas était 10.0.75.1.

Edit: j'ai fini de prototypage le concept sur GitHub. Check out: https://github.com/sivabudh/system-in-a-box

tout d'abord, ma réponse est orientée vers 2 groupes de personnes: ceux qui utilisent un Mac, et ceux qui utilisent Linux.

le host mode réseau ne fonctionne pas sur un Mac. Vous devez utiliser un alias IP, voir: https://stackoverflow.com/a/43541681/2713729

Qu'est-ce qu'un mode réseau hôte? Voir: https://docs.docker.com/engine/reference/run/#/network-settings

Deuxièmement, pour ceux d'entre vous qui utilisez Linux (mon expérience directe a été avec Ubuntu 14.04 LTS et je suis la mise à niveau à 16.04 LTS en production bientôt), Oui , vous pouvez faire le service courant à l'intérieur d'un conteneur Docker se connecter à localhost services fonctionnant sur L'hôte Docker (par ex. votre ordinateur portable).

comment?

la clé est que lorsque vous exécutez le conteneur Docker, vous devez l'exécuter avec le mode host . La commande ressemble à ceci:

docker run --network="host" -id <Docker image ID>

Quand vous faites un ifconfig (vous aurez besoin de apt-get install net-tools votre conteneur pour ifconfig pour être appelable) à l'intérieur de votre conteneur, vous verrez que la les interfaces réseau sont les mêmes que celles de L'hôte Docker (p. ex. votre ordinateur portable).

il est important de noter que je suis un utilisateur Mac, mais je lance Ubuntu sous Parallels, donc utiliser un Mac n'est pas un inconvénient. ;- )

et c'est ainsi que vous connectez le conteneur Nginx au MySQL tournant sur un localhost .

Solution pour Linux (kernel >=3.6).

Ok, votre serveur localhost a une interface docker par défaut docker0 avec adresse ip 172.17.0.1 . Votre conteneur a commencé avec les paramètres réseau par défaut --net="bridge" .

1. activer route_localnet pour l'interface docker0:
   
   $ sysctl -w net.ipv4.conf.docker0.route_localnet=1
2. ajouter les règles suivantes: iptables:
   
   $ iptables -t nat -I PREROUTING -i docker0 -d 172.17.0.1 -p tcp --dport 3306 -j DNAT --to 127.0.0.1:3306

$ iptables -t filter -I INPUT -i docker0 -d 127.0.0.1 -p tcp --dport 3306 -j ACCEPT
3. créer utilisateur mysql avec accès à partir de ' % ' qui signifie - de n'importe qui, à l'exclusion de localhost:
   
   CREATE USER 'user'@'%' IDENTIFIED BY 'password';
4. changement dans votre script l'adresse mysql-server à 172.17.0.1

De la documentation du noyau :

route_localnet - booléen: ne pas considérer les adresses loopback comme source ou destination martienne pendant l'acheminement. Cela permet l'utilisation de 127/8 à des fins de routage local ( faux par défaut ).

voici ma solution : cela fonctionne pour mon cas

• mettre le serveur mysql local à l'accès public par commentaire #bind-address = 127.0.0.1 dans /etc/mysql/mysql.conf.d

• redémarrer le serveur mysql sudo /etc/init.d/mysql restart

• exécutez la commande suivante pour ouvrir l'accès root utilisateur n'importe quel hôte mysql -uroot -proot GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION; FLUSH PRIVILEGES;

• créer script sh : run_docker.sh

    #!bin/bash

    HOSTIP=`ip -4 addr show scope global dev eth0 | grep inet | awk '{print $2}' | cut -d / -f 1`


      docker run -it -d --name web-app \
                  --add-host=local:${HOSTIP} \
                  -p 8080:8080 \
                  -e DATABASE_HOST=${HOSTIP} \
                  -e DATABASE_PORT=3306 \
                  -e DATABASE_NAME=demo \
                  -e DATABASE_USER=root \
                  -e DATABASE_PASSWORD=root \
                  sopheamak/springboot_docker_mysql

  

• exécuter avec docker-compositeur

  version: '2.1'
  
  services:
  
  
    tomcatwar:
       extra_hosts:
          - "local:10.1.2.232"
       image: sopheamak/springboot_docker_mysql
  
  
       ports:
           - 8080:8080
       environment:
              - DATABASE_HOST=local
              - DATABASE_USER=root
              - DATABASE_PASSWORD=root
              - DATABASE_NAME=demo
              - DATABASE_PORT=3306

Je ne suis pas d'accord avec la réponse de Thomasleveil.

rendre mysql bind à 172.17.42.1 empêchera d'autres programmes utilisant la base de données sur l'hôte de l'atteindre. Cela ne fonctionnera que si tous les utilisateurs de votre base de données sont dockerisés.

Making mysql bind to 0.0.0.0 ouvrira la base de données au monde extérieur, ce qui est non seulement une très mauvaise chose à faire, mais aussi contraire à ce que l'auteur de la question originale veut faire. Il dit explicitement "la MySql court sur localhost et de ne pas exposer un port au monde extérieur, ainsi son lié sur localhost"

pour répondre au commentaire de ivant

"Pourquoi ne pas lier mysql pour docker0 ainsi?"

ce n'est pas possible. La documentation mysql/mariadb indique explicitement qu'il n'est pas possible de se lier à plusieurs interfaces. Vous ne pouvez vous lier qu'à 0, 1 ou toutes les interfaces.

en conclusion, je N'ai pas trouvé n'importe quel moyen d'atteindre la base de données (localhost seulement) sur l'hôte à partir d'un conteneur docker. Qui semble définitivement comme un très très commun, mais je ne sais pas comment le faire.

la solution la plus simple pour Mac OSX

il suffit d'utiliser l'adresse IP de votre Mac. Sur le Mac lancer pour obtenir l'adresse IP et l'utiliser à partir de l'intérieur du conteneur:

$ ifconfig | grep 'inet 192'| awk '{ print }'

aussi longtemps que le serveur tournant localement sur votre Mac ou dans un autre conteneur docker écoute 0.0.0.0, le conteneur docker sera en mesure d'atteindre cette adresse.

si vous voulez juste accéder à un autre docker conteneur qui est à l'écoute sur 0.0.0.0.0 vous pouvez utiliser 172.17.0.1

les Cgroupes et les Namespaces jouent un rôle majeur dans l'écosystème des conteneurs.

Namespace fournir une couche d'isolement. Chaque conteneur fonctionne dans un espace de noms séparé et son accès est limité à cet espace de noms. Les Gcroups contrôlent l'utilisation des ressources de chaque conteneur, tandis que Namespace contrôle ce qu'un processus peut voir et accéder à la ressource respective.

Voici la compréhension de base de la approche de la solution que vous pourriez suivre,

Utiliser L'Espace De Nom De Réseau

Lorsqu'un conteneur sort de l'image, une interface réseau est définie et créée. Cela donne au conteneur l'adresse IP unique et l'interface.

$ docker run -it alpine ifconfig

en changeant le namespace à l'hôte, les réseaux de cotainers ne restent pas isolés à son interface, le processus aura accès à l'interface réseau des machines hôtes.

$ docker run -it --net=host alpine ifconfig

si le processus écoute les ports, ils seront écoutés sur l'interface hôte et mis en correspondance avec le conteneur.

Utiliser le PID de l'espace de Noms En changeant l'espace de noms Pid permet à un conteneur d'interagir avec d'autres processus au-delà de sa portée normale.

ce conteneur fonctionnera dans son propre espace de nom.

$ docker run -it alpine ps aux

en changeant le namespace à l'hôte, le conteneur peut également voir tous les autres processus tournant sur le système.

$ docker run -it --pid=host alpine ps aux

Partage De L'Espace De Noms

c'est une mauvaise pratique de faire cela en production parce que vous êtes en train de sortir du modèle de sécurité des conteneurs qui pourrait s'ouvrir à des vulnérabilités, et un accès facile à eavesdropper. Ce n'est que pour déboguer les outils et minimiser les failles dans la sécurité des conteneurs.

le premier conteneur est nginx server. Ce créera un nouveau namespace de réseau et de processus. Ce conteneur se liera au port 80 de l'interface réseau nouvellement créée.

$ docker run -d --name http nginx:alpine

un autre conteneur peut maintenant réutiliser cet espace de nom,

$ docker run --net=container:http mohan08p/curl curl -s localhost

aussi, ce conteneur peut voir l'interface avec les processus dans un conteneur partagé.

$ docker run --pid=container:http alpine ps aux

cela vous permettra de donner plus de privilèges aux conteneurs sans changer ou redémarrer l'application. Dans de la même façon, vous pouvez vous connecter à mysql sur l'hôte, exécuter et déboguer votre application. Mais, ce n'est pas recommander d'aller par ce chemin. Espérons que cela aide.

vous pouvez obtenir l'adresse ip de l'hôte en utilisant l'image alpine

docker run --rm alpine ip route | awk 'NR==1 {print }'

ce serait plus cohérent car vous utilisez toujours alpine pour exécuter la commande.

similaire à la réponse de Mariano, vous pouvez utiliser la même commande pour définir une variable d'environnement

DOCKER_HOST=$(docker run --rm alpine ip route | awk 'NR==1 {print }') docker-compose up

Pour Machine Windows: -

exécuter la commande ci-dessous pour exposer le port docker au hasard pendant le temps de construction

$docker run -d --name MyWebServer -P mediawiki

dans la liste des conteneurs ci-dessus, vous pouvez voir le port assigné comme 32768. Essayez d'accéder à

localhost:32768 

You peut voir la page mediawiki

vous pouvez utiliser ngrok pour créer un tunnel sécurisé vers votre machine localhost et ensuite exposer ce tunnel à votre conteneur docker.

ngrok est libre à partir du 22/05/2017.

Suit:

1) passer à ngrok

2) télécharger le client ngrok et suivre les instructions d'installation

3) inscrivez pour un compte et ils fourniront un jeton d'authentification. L'inscription est nécessaire car ngrok ne vous donne le tunnel du port tcp qu'après l'inscription. Il n'y a aucun coût ou carte de crédit nécessaire pour vous inscrire.

4) dans votre terminal faites ngrok tcp 3306 . 3306 est le port que mysql fonctionne sur mon local, vous pouvez le faire avec n'importe quel autre port.

5) vous recevrez une adresse de l'étape 4 comme ceci: tcp://0.tcp.ngrok.io:10117 . C'est la connexion du tunnel à votre machine locale. 0.tcp.ngrok.io est mappé à votre localhost et le port 10117 est mappé à votre port local 3306 . Maintenant, vous pouvez accéder à votre port 3306 localhost de n'importe où en utilisant cette adresse, y compris n'importe quel conteneur docker tournant sur cette machine. Dans votre conteneur docker(où qu'il se trouve), en supposant que vous avez mysql client déjà installé, faites ce qui suit:

mysql --host 0.tcp.ngrok.io --port 10117 -u root

Vous pourrez vous connecter à votre compte root de votre machine locale depuis l'intérieur du conteneur docker!

j'ai blogué sur cette solution Voir plus de détails ici