Ich habe also ein Nginx, das in einem Docker-Container ausgeführt wird. Ich habe ein MySQL, das auf localhost ausgeführt wird. Ich möchte über mein Nginx eine Verbindung zum MySQL herstellen. MySql wird auf localhost ausgeführt und setzt einen Port nicht der Außenwelt aus. Daher ist es an localhost gebunden, nicht an die IP-Adresse des Computers.

Gibt es eine Möglichkeit, über diesen Docker-Container eine Verbindung zu dieser MySQL oder einem anderen Programm auf localhost herzustellen?

Diese Frage unterscheidet sich von "So erhalten Sie die IP-Adresse des Docker-Hosts aus einem Docker-Container heraus", da die IP-Adresse des Docker-Hosts die öffentliche oder die private IP im Netzwerk sein kann, die möglicherweise oder möglicherweise nicht innerhalb des Docker-Containers erreichbar sein (ich meine öffentliche IP, wenn sie bei AWS gehostet wird oder so). Selbst wenn Sie die IP-Adresse des Docker-Hosts haben, bedeutet dies nicht, dass Sie innerhalb des Containers eine Verbindung zum Docker-Host herstellen können, da die IP-Adresse Ihres Docker-Netzwerks möglicherweise Overlay, Host, Bridge, Macvlan usw. ist, was die Erreichbarkeit von einschränkt diese IP-Adresse.

Bearbeiten: Wenn Sie Docker-for-Mac oder Docker-for-Windows 18.03+ verwenden, stellen Sie einfach über den Host eine Verbindung zu Ihrem MySQL-Dienst her host.docker.internal(anstelle der 127.0.0.1in Ihrer Verbindungszeichenfolge).

Ab Docker 18.09.3 funktioniert dies unter Docker-for-Linux nicht mehr. Ein Fix wurde am 8. März 2019 eingereicht und wird hoffentlich in die Codebasis integriert. Bis dahin besteht eine Problemumgehung darin, einen Container zu verwenden, wie in der Antwort von qoomon beschrieben .

2020-01: Einige Fortschritte wurden erzielt . Wenn alles gut geht, sollte dies in Docker 20.04 landen

TLDR

Verwenden Sie --network="host"in Ihrem docker runBefehl, dann zeigt 127.0.0.1in Ihrem Docker-Container auf Ihren Docker-Host.

Hinweis: Dieser Modus funktioniert laut Dokumentation nur unter Docker für Linux .

Hinweis zu den Docker-Container-Netzwerkmodi

Docker bietet verschiedene Netzwerkmodi beim Ausführen von Containern. Abhängig vom gewählten Modus stellen Sie eine unterschiedliche Verbindung zu Ihrer MySQL-Datenbank her, die auf dem Docker-Host ausgeführt wird.

Docker ausführen --network = "Brücke" (Standard)

Docker erstellt eine docker0standardmäßig benannte Brücke . Sowohl der Docker-Host als auch die Docker-Container haben eine IP-Adresse auf dieser Bridge.

Geben sudo ip addr show docker0Sie auf dem Docker-Host Folgendes ein: Die Ausgabe sieht folgendermaßen aus:

[vagrant@docker:~] $ sudo ip addr show docker0
4: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
    link/ether 56:84:7a:fe:97:99 brd ff:ff:ff:ff:ff:ff
    inet 172.17.42.1/16 scope global docker0
       valid_lft forever preferred_lft forever
    inet6 fe80::5484:7aff:fefe:9799/64 scope link
       valid_lft forever preferred_lft forever

Hier hat mein Docker-Host also die IP-Adresse 172.17.42.1auf demdocker0 Netzwerkschnittstelle.

Starten Sie nun einen neuen Container und rufen Sie eine Shell auf: docker run --rm -it ubuntu:trusty bashund innerhalb des Containertyps, ip addr show eth0um herauszufinden, wie die Hauptnetzwerkschnittstelle eingerichtet ist:

root@e77f6a1b3740:/# ip addr show eth0
863: eth0: <BROADCAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 66:32:13:f0:f1:e3 brd ff:ff:ff:ff:ff:ff
    inet 172.17.1.192/16 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::6432:13ff:fef0:f1e3/64 scope link
       valid_lft forever preferred_lft forever

Hier hat mein Container die IP-Adresse 172.17.1.192. Schauen Sie sich nun die Routing-Tabelle an:

root@e77f6a1b3740:/# route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         172.17.42.1     0.0.0.0         UG    0      0        0 eth0
172.17.0.0      *               255.255.0.0     U     0      0        0 eth0

Daher wird die IP-Adresse des Docker-Hosts 172.17.42.1als Standardroute festgelegt und kann von Ihrem Container aus aufgerufen werden.

root@e77f6a1b3740:/# ping 172.17.42.1
PING 172.17.42.1 (172.17.42.1) 56(84) bytes of data.
64 bytes from 172.17.42.1: icmp_seq=1 ttl=64 time=0.070 ms
64 bytes from 172.17.42.1: icmp_seq=2 ttl=64 time=0.201 ms
64 bytes from 172.17.42.1: icmp_seq=3 ttl=64 time=0.116 ms

Docker ausführen --network = "Host"

Alternativ können Sie einen Docker-Container mit den Netzwerkeinstellungenhost ausführen . Ein solcher Container teilt den Netzwerkstapel mit dem Docker-Host und aus der Sicht des Containers localhost(oder127.0.0.1 verweist ) auf den Docker-Host.

Beachten Sie, dass jeder in Ihrem Docker-Container geöffnete Port auf dem Docker-Host geöffnet wird. Und das ohne das -poder-P docker run Option .

IP-Konfiguration auf meinem Docker-Host:

[vagrant@docker:~] $ ip addr show eth0
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 08:00:27:98:dc:aa brd ff:ff:ff:ff:ff:ff
    inet 10.0.2.15/24 brd 10.0.2.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::a00:27ff:fe98:dcaa/64 scope link
       valid_lft forever preferred_lft forever

und aus einem Docker-Container im Host- Modus:

[vagrant@docker:~] $ docker run --rm -it --network=host ubuntu:trusty ip addr show eth0
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 08:00:27:98:dc:aa brd ff:ff:ff:ff:ff:ff
    inet 10.0.2.15/24 brd 10.0.2.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::a00:27ff:fe98:dcaa/64 scope link
       valid_lft forever preferred_lft forever

Wie Sie sehen können, haben sowohl der Docker-Host als auch der Docker-Container genau dieselbe Netzwerkschnittstelle und als solche dieselbe IP-Adresse.

Herstellen einer Verbindung zu MySQL über Container

Brückenmodus

Um von Containern im Bridge-Modus auf MySQL zuzugreifen, das auf dem Docker-Host ausgeführt wird , müssen Sie sicherstellen, dass der MySQL-Dienst auf Verbindungen mit der 172.17.42.1IP-Adresse wartet.

Stellen Sie dazu sicher, dass Sie entweder bind-address = 172.17.42.1oder bind-address = 0.0.0.0in Ihrer MySQL-Konfigurationsdatei (my.cnf) haben.

Wenn Sie eine Umgebungsvariable mit der IP-Adresse des Gateways festlegen müssen, können Sie den folgenden Code in einem Container ausführen:

export DOCKER_HOST_IP=$(route -n | awk '/UG[ \t]/{print $2}')

Verwenden Sie dann in Ihrer Anwendung die DOCKER_HOST_IPUmgebungsvariable, um die Verbindung zu MySQL herzustellen.

Hinweis: Wenn Sie bind-address = 0.0.0.0Ihren MySQL-Server verwenden, wartet er auf Verbindungen auf allen Netzwerkschnittstellen. Das bedeutet, dass Ihr MySQL-Server über das Internet erreichbar ist. Stellen Sie sicher, dass Sie die Firewall-Regeln entsprechend einrichten.

Hinweis 2: Wenn Sie bind-address = 172.17.42.1Ihren MySQL-Server verwenden, werden keine Verbindungen zu hergestellt 127.0.0.1. Prozesse, die auf dem Docker-Host ausgeführt werden und eine Verbindung zu MySQL herstellen möchten, müssen die 172.17.42.1IP-Adresse verwenden.

Host-Modus

Um von Containern im Host-Modus auf MySQL zuzugreifen, das auf dem Docker-Host ausgeführt wird , können Sie bind-address = 127.0.0.1Ihre MySQL-Konfiguration beibehalten. Sie müssen lediglich eine Verbindung 127.0.0.1von Ihren Containern aus herstellen:

[vagrant@docker:~] $ docker run --rm -it --network=host mysql mysql -h 127.0.0.1 -uroot -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 36
Server version: 5.5.41-0ubuntu0.14.04.1 (Ubuntu)

Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Hinweis: Verwenden Sie mysql -h 127.0.0.1und nicht mysql -h localhost; Andernfalls würde der MySQL-Client versuchen, eine Verbindung über einen Unix-Socket herzustellen.

Für MacOS und Windows

Docker v 18.03 und höher (seit dem 21. März 2018)

Verwenden Sie Ihre interne IP-Adresse oder stellen Sie eine Verbindung zum speziellen DNS-Namen her host.docker.internal der in die vom Host verwendete interne IP-Adresse aufgelöst wird.

Linux-Unterstützung ausstehend https://github.com/docker/for-linux/issues/264

MacOS mit früheren Versionen von Docker

Docker für Mac v 17.12 bis v 18.02

Wie oben, aber docker.for.mac.host.internalstattdessen verwenden.

Docker für Mac v 17.06 bis v 17.11

Wie oben, aber docker.for.mac.localhoststattdessen verwenden.

Docker für Mac 17.05 und niedriger

Um vom Docker-Container aus auf den Host-Computer zuzugreifen, müssen Sie einen IP-Alias ​​an Ihre Netzwerkschnittstelle anhängen. Sie können jede gewünschte IP-Adresse binden. Stellen Sie jedoch sicher, dass Sie sie nicht für andere Zwecke verwenden.

sudo ifconfig lo0 alias 123.123.123.123/24

Stellen Sie dann sicher, dass Ihr Server die oben genannte IP abhört oder 0.0.0.0. Wenn localhost abgehört 127.0.0.1wird, wird die Verbindung nicht akzeptiert.

Zeigen Sie dann einfach mit Ihrem Docker-Container auf diese IP und Sie können auf den Host-Computer zugreifen!

Zum Testen können Sie so etwas wie curl -X GET 123.123.123.123:3000im Container ausführen .

Der Alias ​​wird bei jedem Neustart zurückgesetzt. Erstellen Sie daher bei Bedarf ein Startskript.

Lösung und weitere Dokumentation hier: https://docs.docker.com/docker-for-mac/networking/#use-cases-and-workarounds

Ich mache einen Hack ähnlich den obigen Posts, um die lokale IP einem Aliasnamen (DNS) im Container zuzuordnen. Das Hauptproblem besteht darin, mit einem einfachen Skript, das sowohl unter Linux als auch unter OSX funktioniert, dynamisch die Host-IP-Adresse zu erhalten . Ich habe dieses Skript erstellt, das in beiden Umgebungen funktioniert (auch in der Linux-Distribution mit "$LANG" != "en_*"konfigurierter Konfiguration):

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

Wenn Sie Docker Compose verwenden, lautet die vollständige Konfiguration wie folgt:

Startskript (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 $2 }' | cut -f2 -d: | head -n1)
docker-compose -f docker-compose.yml up

docker-compose.yml :

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

Ändern Sie dann http://localhostauf http://dockerhostin Ihrem Code.

Eine ausführlichere Anleitung zum Anpassen des DOCKERHOSTSkripts finden Sie in diesem Beitrag mit einer Erläuterung der Funktionsweise.

Dies funktionierte für mich auf einem NGINX / PHP-FPM-Stack, ohne Code oder Netzwerk zu berühren, mit dem die App nur eine Verbindung herstellen möchte localhost

Montieren mysqld.sock vom Host in den Container.

Suchen Sie den Speicherort der Datei mysql.sock auf dem Host, auf dem mysql ausgeführt wird:
netstat -ln | awk '/mysql(.*)?\.sock/ { print $9 }'

Hängen Sie diese Datei dort ein, wo sie im Docker erwartet wird:
docker run -v /hostpath/to/mysqld.sock:/containerpath/to/mysqld.sock

Mögliche Standorte von 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

Bis host.docker.internales für jede Plattform funktioniert, können Sie meinen Container ohne manuelles Setup als NAT-Gateway verwenden:

https://github.com/qoomon/docker-host

Lösung für Linux (Kernel> = 3.6).

Ok, Ihr localhost-Server verfügt über die Standard-Docker-Schnittstelle docker0 mit der IP-Adresse 172.17.0.1 . Ihr Container wurde mit den Standardeinstellungen für das Netzwerk gestartet --net = "bridge" .

1. Aktivieren Sie route_localnet für die Docker0-Schnittstelle:
   $ sysctl -w net.ipv4.conf.docker0.route_localnet=1
2. Fügen Sie diese Regeln zu iptables hinzu:
   $ 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. Erstellen Sie einen MySQL-Benutzer mit Zugriff von '%', dh von jedem, außer localhost:
   CREATE USER 'user'@'%' IDENTIFIED BY 'password';
4. Ändern Sie in Ihrem Skript die MySQL-Server-Adresse in 172.17.0.1

Aus der Kerneldokumentation :

route_localnet - BOOLEAN: Berücksichtigen Sie Loopback-Adressen beim Routing nicht als Marsquelle oder -ziel . Dies ermöglicht die Verwendung von 127/8 für lokales Routing ( Standard FALSE ).

Lösung für Windows 10

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

Sie können den DNS-Namen des Hosts verwenden docker.for.win.localhost, um die interne IP-Adresse zu ermitteln. (Warnung einige Quellen erwähnt, windowsaber es sollte sein win)

Übersicht
Ich musste etwas Ähnliches tun, nämlich eine Verbindung von meinem Docker-Container zu meinem lokalen Host herstellen, auf dem das Azure Storage Emulatorund ausgeführt wurde CosmosDB Emulator.

Das Azure Storage Emulatorhört standardmäßig auf 127.0.0.1 zu , während Sie die IP- Adresse auch ändern können, suchte ich nach einer Lösung, die mit Standardeinstellungen funktioniert.

Dies funktioniert auch für die Verbindung von meinem Docker-Container zu SQL Serverund IIS, die beide lokal auf meinem Host mit Standard-Porteinstellungen ausgeführt werden.

Sehr einfach und schnell, überprüfen Sie Ihre Host-IP mit ifconfig (Linux) oder ipconfig (Windows) und erstellen Sie dann eine

docker-compose.yml

version: '3' # specify docker-compose version

services:
  nginx:
    build: ./ # specify the directory of the Dockerfile
    ports:
      - "8080:80" # specify port mapping
    extra_hosts:
      - "dockerhost:<yourIP>"

Auf diese Weise kann Ihr Container auf Ihren Host zugreifen. Denken Sie beim Zugriff auf Ihre Datenbank daran, den zuvor angegebenen Namen zu verwenden, in diesem Fall "Dockerhost" und den Port Ihres Hosts, auf dem die Datenbank ausgeführt wird

Bei Verwendung von Docker Toolbox unter Windows 10 Home hat keine der Antworten für mich funktioniert, 10.0.2.2 jedoch, da VirtualBox verwendet wird, das den Host für die VM unter dieser Adresse verfügbar macht.

Wenn Sie unter Windows den Bridge-Netzwerktreiber verwenden, möchten Sie MySQL speziell an die IP-Adresse der Hyper-V-Netzwerkschnittstelle binden.

Dies erfolgt über die Konfigurationsdatei im normalerweise ausgeblendeten Ordner C: \ ProgramData \ MySQL.

Die Bindung an 0.0.0.0 funktioniert nicht. Die benötigte Adresse wird auch in der Docker-Konfiguration angezeigt und war in meinem Fall 10.0.75.1.

Bearbeiten: Am Ende habe ich das Konzept auf GitHub prototypisiert. Überprüfen Sie heraus: https://github.com/sivabudh/system-in-a-box

Erstens richtet sich meine Antwort an zwei Personengruppen: diejenigen, die einen Mac verwenden, und diejenigen, die Linux verwenden.

Der Host- Netzwerkmodus funktioniert auf einem Mac nicht. Sie müssen einen IP-Alias ​​verwenden, siehe: https://stackoverflow.com/a/43541681/2713729

Was ist ein Host-Netzwerkmodus? Siehe: https://docs.docker.com/engine/reference/run/#/network-settings

Zweitens, für diejenigen unter Ihnen, die Linux verwenden (meine direkte Erfahrung war mit Ubuntu 14.04 LTS und ich aktualisiere bald auf 16.04 LTS in der Produktion), ja , Sie können den Dienst, der in einem Docker-Container ausgeführt wird, mit verbindenlocalhost Diensten die auf dem ausgeführt werden Docker-Host (z. B. Ihr Laptop).

Wie?

Der Schlüssel ist, wenn Sie den Docker-Container ausführen, müssen Sie ihn im Host- Modus ausführen . Der Befehl sieht folgendermaßen aus:

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

Wenn Sie eine ifconfig(Sie müssen apt-get install net-toolsIhren Container benötigen, ifconfigum aufrufbar zu sein) in Ihrem Container ausführen, werden Sie feststellen, dass die Netzwerkschnittstellen mit denen auf dem Docker-Host (z. B. Ihrem Laptop) identisch sind.

Es ist wichtig zu beachten, dass ich ein Mac-Benutzer bin, aber Ubuntu unter Parallels ausführe, sodass die Verwendung eines Mac kein Nachteil ist. ;-);

Und so verbinden Sie den NGINX-Container mit MySQL, das auf einem ausgeführt wird localhost.

Einfachste Lösung für Mac OSX

Verwenden Sie einfach die IP-Adresse Ihres Mac. Führen Sie dies auf dem Mac aus, um die IP-Adresse abzurufen und aus dem Container heraus zu verwenden:

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

Solange der Server, der lokal auf Ihrem Mac oder in einem anderen Docker-Container ausgeführt wird, 0.0.0.0 abhört, kann der Docker-Container diese Adresse erreichen.

Wenn Sie nur auf einen anderen Docker-Container zugreifen möchten, der 0.0.0.0 abhört, können Sie 172.17.0.1 verwenden

Dies ist keine Antwort auf die eigentliche Frage. So habe ich ein ähnliches Problem gelöst. Die Lösung kommt vollständig von: Definieren Sie Docker Container Networking, damit Container kommunizieren können . Vielen Dank an Nic Raboy

Lassen Sie dies hier für andere, die möglicherweise REST-Aufrufe zwischen einem Container und einem anderen ausführen möchten. Beantwortet die Frage: Was soll anstelle von localhost in einer Docker-Umgebung verwendet werden?

Erfahren Sie, wie Ihr Netzwerk aussieht docker network ls

Erstellen Sie ein neues Netzwerk docker network create -d my-net

Starten Sie den ersten Container docker run -d -p 5000:5000 --network="my-net" --name "first_container" <MyImage1:v0.1>

Überprüfen Sie die Netzwerkeinstellungen für den ersten Container docker inspect first_container. "Netzwerke": sollte 'my-net' haben

Starten Sie den zweiten Container docker run -d -p 6000:6000 --network="my-net" --name "second_container" <MyImage2:v0.1>

Überprüfen Sie die Netzwerkeinstellungen für den zweiten Container docker inspect second_container. "Netzwerke": sollte 'my-net' haben

ssh in deinen zweiten container docker exec -it second_container shoder docker exec -it second_container bash.

Innerhalb des zweiten Containers können Sie den ersten Container an pingen ping first_container. Auch Ihre Code-Aufrufe wie http://localhost:5000können durch ersetzt werdenhttp://first_container:5000

Für Windows,

Ich habe die Datenbank-URL in der Frühjahrskonfiguration geändert: spring.datasource.url=jdbc:postgresql://host.docker.internal:5432/apidb

Erstellen Sie dann das Image und führen Sie es aus. Es hat bei mir funktioniert.

Ich bin mit der Antwort von Thomasleveil nicht einverstanden.

Wenn Sie MySQL an 172.17.42.1 binden, wird verhindert, dass andere Programme die Datenbank auf dem Host verwenden, um darauf zuzugreifen. Dies funktioniert nur, wenn alle Ihre Datenbankbenutzer dockerisiert sind.

Wenn Sie MySQL an 0.0.0.0 binden, wird die Datenbank für die Außenwelt geöffnet. Dies ist nicht nur eine sehr schlechte Sache, sondern widerspricht auch dem, was der ursprüngliche Frageautor tun möchte. Er sagt ausdrücklich: "MySql läuft auf localhost und setzt einen Port nicht der Außenwelt aus, daher ist es an localhost gebunden."

Um den Kommentar von ivant zu beantworten

"Warum nicht auch MySQL an Docker0 binden?"

Das ist nicht möglich. In der mysql / mariadb-Dokumentation heißt es ausdrücklich, dass es nicht möglich ist, an mehrere Schnittstellen zu binden. Sie können nur an 0, 1 oder alle Schnittstellen binden.

Als Fazit habe ich KEINE Möglichkeit gefunden, die Datenbank (nur localhost) auf dem Host von einem Docker-Container aus zu erreichen. Das scheint definitiv ein sehr sehr verbreitetes Muster zu sein, aber ich weiß nicht, wie ich es machen soll.

Hier ist meine Lösung: Es funktioniert für meinen Fall

• #bind-address = 127.0.0.1 Stellen Sie den lokalen MySQL-Server per Kommentar in /etc/mysql/mysql.conf.d auf öffentlichen Zugriff ein

• Starten Sie den MySQL-Server neu sudo /etc/init.d/mysql restart

• Führen Sie den folgenden Befehl aus, um den Benutzerstammzugriff auf einen beliebigen Host zu öffnen mysql -uroot -proot GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION; FLUSH PRIVILEGES;

• Erstellen Sie ein sh-Skript: run_docker.sh

    #! bin / bash

    HOSTIP = `ip -4 addr show scope global dev eth0 | grep inet | awk '{print \ $ 2}' | schneide -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

  

• mit Docker-Composer ausführen

  Version: '2.1'
  
  
  Dienstleistungen:
  
    Tomcatwar:
       extra_hosts:
          - "local: 10.1.2.232"
       Bild: sopheamak / springboot_docker_mysql
  
       Häfen:
           - 8080: 8080
       Umgebung:
              - DATABASE_HOST = lokal
              - DATABASE_USER = root
              - DATABASE_PASSWORD = root
              - DATABASE_NAME = Demo
              - DATABASE_PORT = 3306

Es kommen mehrere Lösungen in den Sinn:

1. Verschieben Sie Ihre Abhängigkeiten zuerst in Container
2. Machen Sie Ihre anderen Dienste extern zugänglich und stellen Sie mit dieser externen IP eine Verbindung zu ihnen her
3. Führen Sie Ihre Container ohne Netzwerkisolation aus
4. Vermeiden Sie die Verbindung über das Netzwerk. Verwenden Sie stattdessen einen Socket, der als Volume bereitgestellt wird

Der Grund, warum dies nicht sofort funktioniert, ist, dass Container standardmäßig mit ihrem eigenen Netzwerk-Namespace ausgeführt werden. Dies bedeutet, dass localhost (oder 127.0.0.1, das auf die Loopback-Schnittstelle verweist) pro Container eindeutig ist. Wenn Sie eine Verbindung herstellen, wird eine Verbindung zum Container selbst hergestellt und nicht zu Diensten, die außerhalb des Dockers oder innerhalb eines anderen Docker-Containers ausgeführt werden.

Option 1 : Wenn Ihre Abhängigkeit in einen Container verschoben werden kann, würde ich dies zuerst tun. Dadurch wird Ihr Anwendungsstapel portabel, da andere versuchen, Ihren Container in ihrer eigenen Umgebung auszuführen. Sie können den Port weiterhin auf Ihrem Host veröffentlichen, wo andere Dienste, die nicht migriert wurden, ihn weiterhin erreichen können. Sie können den Port sogar auf der localhost-Schnittstelle Ihres Docker-Hosts veröffentlichen, um zu vermeiden, dass er extern mit einer Syntax wie der folgenden -p 127.0.0.1:3306:3306für den veröffentlichten Port zugänglich ist .

Option 2 : Es gibt verschiedene Möglichkeiten, die Host-IP-Adresse innerhalb des Containers zu erkennen, aber es gibt jeweils eine begrenzte Anzahl von Szenarien, in denen sie funktionieren (z. B. Docker für Mac erforderlich). Die portabelste Option besteht darin, Ihre Host-IP mit einer Umgebungsvariablen oder einer Konfigurationsdatei in den Container einzufügen, z.

docker run --rm -e "HOST_IP=$(ip r s 0/0 | awk '{print $3}')" ...

Dies setzt voraus, dass Ihr Dienst diese externe Schnittstelle überwacht, was ein Sicherheitsrisiko darstellen kann. Weitere Methoden zum Abrufen der Host-IP-Adresse aus dem Container finden Sie in diesem Beitrag .

Option 3 : Ohne Netzwerkisolation ausgeführt, dh mit ausgeführt --net host, bedeutet, dass Ihre Anwendung im Namespace des Hostnetzwerks ausgeführt wird. Dies ist weniger isoliert für den Container und bedeutet, dass Sie nicht über ein freigegebenes Docker-Netzwerk mit DNS auf andere Container zugreifen können (stattdessen müssen Sie veröffentlichte Ports verwenden, um auf andere containerisierte Anwendungen zuzugreifen). Für Anwendungen, die auf andere Dienste auf dem Host zugreifen müssen, die nur 127.0.0.1auf dem Host lauschen , kann dies die einfachste Option sein.

Option 4 : Verschiedene Dienste ermöglichen auch den Zugriff über einen dateisystembasierten Socket. Dieser Socket kann als bindmontiertes Volume in den Container eingebunden werden, sodass Sie auf den Hostdienst zugreifen können, ohne über das Netzwerk zu gehen. Für den Zugriff auf die Docker-Engine werden häufig Beispiele für das Mounten /var/run/docker.sockin den Container angezeigt (wodurch dieser Container-Root-Zugriff auf den Host gewährt wird). Mit MySQL können Sie so etwas ausprobieren -v /var/run/mysqld/mysqld.sock:/var/run/mysqld/mysql.sockund dann eine Verbindung herstellen, zu localhostder MySQL über den Socket konvertiert.

Sie können die Host-IP mit Alpine Image erhalten

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

Dies wäre konsistenter, da Sie den Befehl immer mit alpine ausführen.

Ähnlich wie bei Marianos Antwort können Sie denselben Befehl verwenden, um eine Umgebungsvariable festzulegen

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

Unter Linux, wo Sie die Schnittstelle nicht ändern können, an die der localhost-Dienst gebunden ist

Es gibt zwei Probleme, die wir lösen müssen

1. Abrufen der IP des Hosts
2. Bereitstellung unseres Localhost-Service für Docker

Das erste Problem kann mit dem Docker-Host-Image von qoomon gelöst werden , wie aus anderen Antworten hervorgeht.

Sie müssen diesen Container demselben Brückennetzwerk wie Ihr anderer Container hinzufügen, damit Sie darauf zugreifen können. Öffnen Sie ein Terminal in Ihrem Container und stellen Sie sicher, dass Sie pingen können dockerhost.

bash-5.0# ping dockerhost
PING dockerhost (172.20.0.2): 56 data bytes
64 bytes from 172.20.0.2: seq=0 ttl=64 time=0.523 ms

Nun ist das Problem schwieriger, den Dienst für Docker zugänglich zu machen.

Wir können Telnet verwenden, um zu überprüfen, ob wir auf einen Port auf dem Host zugreifen können (möglicherweise müssen Sie diesen installieren).

Das Problem ist, dass unser Container nur auf Dienste zugreifen kann, die an alle Schnittstellen gebunden sind, z. B. SSH:

bash-5.0# telnet dockerhost 22
SSH-2.0-OpenSSH_7.6p1 Ubuntu-4ubuntu0.3

Auf Dienste, die nur an localhost gebunden sind, kann jedoch nicht zugegriffen werden:

bash-5.0# telnet dockerhost 1025
telnet: can't connect to remote host (172.20.0.2): Connection refused

Die richtige Lösung wäre hier, den Dienst an das Docker-Bridge-Netzwerk zu binden. Bei dieser Antwort wird jedoch davon ausgegangen, dass Sie dies nicht ändern können. Also werden wir stattdessen verwenden iptables.

Zuerst müssen wir den Namen des Brückennetzwerks finden, mit dem Docker arbeitet ifconfig. Wenn Sie eine unbenannte Brücke verwenden, ist dies nur der Fall docker0. Wenn Sie jedoch ein benanntes Netzwerk verwenden, wird br-stattdessen eine Bridge verwendet, die mit dem Docker beginnt . Meins ist br-5cd80298d6f4.

Sobald wir den Namen dieser Brücke haben, müssen wir das Routing von dieser Brücke zu localhost zulassen. Dies ist aus Sicherheitsgründen standardmäßig deaktiviert:

sysctl -w net.ipv4.conf.<bridge_name>.route_localnet=1

Nun, um unsere iptablesRegel aufzustellen . Da unser Container nur auf Ports im Docker-Bridge-Netzwerk zugreifen kann, geben wir vor, dass unser Service tatsächlich an einen Port in diesem Netzwerk gebunden ist.

Dazu leiten wir alle Anfragen an <docker_bridge>:portweiterlocalhost:port

iptables -t nat -A PREROUTING -p tcp -i <docker_bridge_name> --dport <service_port> -j DNAT --to-destination 127.0.0.1:<service_port>

Zum Beispiel für meinen Dienst an Port 1025

iptables -t nat -A PREROUTING -p tcp -i br-5cd80298d6f4 --dport 1025 -j DNAT --to-destination 127.0.0.1:1025

Sie sollten jetzt über den Container auf Ihren Dienst zugreifen können:

bash-5.0# telnet dockerhost 1025
220 127.0.0.1 ESMTP Service Ready

Sie müssen das Gateway kennen ! Meine Lösung mit dem lokalen Server bestand darin, ihn unter 0.0.0.0:8000verfügbar zu machen, dann Docker mit Subnetz auszuführen und Container wie folgt auszuführen :

docker network create --subnet=172.35.0.0/16 --gateway 172.35.0.1 SUBNET35
docker run -d -p 4444:4444 --net SUBNET35 <container-you-want-run-place-here>

Jetzt können Sie über auf Ihren Loopback zugreifen http://172.35.0.1:8000

Versuche dies:

version: '3.5'
services:
  yourservice-here:
    container_name: container_name
    ports:
      - "4000:4000"
    extra_hosts: # <---- here
      - localhost:192.168.1.202
      - or-vitualhost.local:192.168.1.202

Bekommen 192.168.1.202 , verwendetifconfig

Das hat bei mir funktioniert. Ich hoffe das hilft!

Die CGroups und Namespaces spielen eine wichtige Rolle im Container-Ökosystem.

Der Namespace bietet eine Isolationsschicht. Jeder Container wird in einem separaten Namespace ausgeführt und sein Zugriff ist auf diesen Namespace beschränkt. Die Cgroups steuern die Ressourcennutzung jedes Containers, während der Namespace steuert, was ein Prozess sehen und auf die jeweilige Ressource zugreifen kann.

Hier ist das grundlegende Verständnis des Lösungsansatzes, dem Sie folgen könnten:

Verwenden Sie den Netzwerk-Namespace

Wenn ein Container aus dem Image heraus erscheint, wird eine Netzwerkschnittstelle definiert und erstellt. Dies gibt dem Container eine eindeutige IP-Adresse und Schnittstelle.

$ docker run -it alpine ifconfig

Durch Ändern des Namespace in Host bleiben die Cotainer-Netzwerke nicht von der Schnittstelle isoliert. Der Prozess hat Zugriff auf die Netzwerkschnittstelle des Host-Computers.

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

Wenn der Prozess Ports überwacht, werden diese auf der Host-Schnittstelle abgehört und dem Container zugeordnet.

PID-Namespace verwenden Durch Ändern des PID-Namespace kann ein Container mit anderen Prozessen interagieren, die über seinen normalen Bereich hinausgehen.

Dieser Container wird in einem eigenen Namespace ausgeführt.

$ docker run -it alpine ps aux

Durch Ändern des Namespace in den Host kann der Container auch alle anderen auf dem System ausgeführten Prozesse anzeigen.

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

Namespace teilen

Dies ist eine schlechte Vorgehensweise in der Produktion, da Sie aus dem Containersicherheitsmodell ausbrechen, das sich möglicherweise für Sicherheitslücken und einen einfachen Zugriff auf Lauscher öffnet. Dies dient nur zum Debuggen von Tools und zum Verstehen der Lücken in der Containersicherheit.

Der erste Container ist der Nginx-Server. Dadurch wird ein neuer Netzwerk- und Prozessnamespace erstellt. Dieser Container bindet sich an Port 80 der neu erstellten Netzwerkschnittstelle.

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

Ein anderer Container kann diesen Namespace jetzt wiederverwenden.

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

Dieser Container kann auch die Schnittstelle zu den Prozessen in einem gemeinsam genutzten Container sehen.

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

Auf diese Weise können Sie Containern mehr Berechtigungen erteilen, ohne die Anwendung zu ändern oder neu zu starten. Auf ähnliche Weise können Sie auf dem Host eine Verbindung zu MySQL herstellen, Ihre Anwendung ausführen und debuggen. Es wird jedoch nicht empfohlen, diesen Weg zu gehen. Ich hoffe es hilft.

Für Windows-Computer: -

Führen Sie den folgenden Befehl aus, um den Docker-Port während der Erstellungszeit zufällig verfügbar zu machen

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

In der obigen Containerliste sehen Sie den als 32768 zugewiesenen Port. Versuchen Sie, darauf zuzugreifen

localhost:32768 

Sie können die Mediawiki-Seite sehen

Bis Fix nicht in masterBranch zusammengeführt wird, wird die Host-IP nur aus dem Container heraus ausgeführt:

ip -4 route list match 0/0 | cut -d' ' -f3

(wie von @Mahoney hier vorgeschlagen ).

Ich habe es gelöst, indem ich in MySQL einen Benutzer für die IP des Containers erstellt habe:

$ sudo mysql<br>
mysql> create user 'username'@'172.17.0.2' identified by 'password';<br>
Query OK, 0 rows affected (0.00 sec)

mysql> grant all privileges on database_name.* to 'username'@'172.17.0.2' with grant option;<br>
Query OK, 0 rows affected (0.00 sec)

$ sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf
<br>bind-address        = 172.17.0.1

$ sudo systemctl restart mysql.service

Dann auf Container: jdbc:mysql://<b>172.17.0.1</b>:3306/database_name

Ich übergebe die Host-IP als Umgebungsvariable an den Container. Der Container greift dann über diese Variable auf den Host zu.