Mysql Docker Container für mehrere Container bereitstellen

[Anonymous User]

Hallo,

was Docker und Docker Compose angeht, bin ich noch ein ziemlicher Anfänger und brauche daher eure Hilfe.
Ich habe einen Standardnotes-Server als Docker Compose mitsamt Mysql erstellt.

Nun möchte ich auch einen Nginx Proxy Manager als Docker Compose aufsetzen. Dieser braucht auch eine Mysql Datenbank.

Wie kann ich meinen bereits vorhandenen Mysql Container für den Proxy Manager nutzen?

Ich habe gelesen, dass ich mit einem Bridge Netzwerk die Container linken kann. Das habe ich aber nicht ganz verstanden.

Ist es möglich, in der Docker-compose.yml von dem Proxy Manager den Mysql Container anzugeben, ohne dabei einen neuen Mysql Container zu erstellen?

Spoiler: docker-compose.yml von Standardnotes

version: '3.8'
services:
api-gateway:
image: standardnotes/api-gateway
env_file: docker/api-gateway.env
environment:
PORT: 3000
entrypoint: ["./wait-for.sh", "syncing-server", "3000", "./wait-for.sh", "syncing-server-js", "3000", "./docker/entrypoint.sh", "start-web"]
ports:
- 3000:${EXPOSED_PORT}
networks:
syncing_server: {}

auth:
image: standardnotes/auth
entrypoint: ["./wait-for.sh", "syncing-server-js", "3000", "./docker/entrypoint.sh", "start-worker"]
env_file: docker/auth.env
networks:
syncing_server: {}

syncing-server-js:
image: standardnotes/syncing-server-js
entrypoint: ["./wait-for.sh", "syncing-server", "3000", "./docker/entrypoint.sh", "start-web"]
env_file: docker/syncing-server-js.env
networks:
syncing_server: {}

syncing-server-js-worker:
image: standardnotes/syncing-server-js
entrypoint: ["./wait-for.sh", "syncing-server-js", "3000", "./docker/entrypoint.sh", "start-worker"]
env_file: docker/syncing-server-js.env
networks:
syncing_server: {}

syncing-server:
build: .
entrypoint: ["./wait-for.sh", "db", "3306", "./wait-for.sh", "cache", "6379", "./docker/entrypoint.sh", "start-local"]
env_file: .env
restart: unless-stopped
environment:
DB_HOST: db
REDIS_URL: redis://cache:6379
networks:
standardnotes_proxy:
aliases:
- syncing_server
syncing_server: {}
volumes:
- .:/syncing-server

db:
image: mysql:5.6
environment:
MYSQL_DATABASE: '${DB_DATABASE}'
MYSQL_USER: '${DB_USERNAME}'
MYSQL_PASSWORD: '${DB_PASSWORD}'
MYSQL_ROOT_PASSWORD: '${DB_PASSWORD}'
ports:
- 3306
restart: unless-stopped
command: --default-authentication-plugin=mysql_native_password --character-set-server=utf8 --collation-server=utf8_general_ci
volumes:
- ./data:/var/lib/mysql
networks:
- syncing_server

cache:
image: redis:6.0-alpine
volumes:
- ./cache:/data
ports:
- 6379
networks:
- syncing_server

networks:
syncing_server:
name: syncing_server
standardnotes_proxy:
name: standardnotes

Spoiler: docker-compose.yml von Nginx Proxy Manager

version: "3"
services:
app:
image: 'jc21/nginx-proxy-manager:latest'
restart: unless-stopped
ports:
# These ports are in format <host-port>:<container-port>
- '80:80' # Public HTTP Port
- '443:443' # Public HTTPS Port
- '81:81' # Admin Web Port
# Add any other Stream port you want to expose
# - '21:21' # FTP

# Uncomment the next line if you uncomment anything in the section
# environment:
# Uncomment this if you want to change the location of
# the SQLite DB file within the container
# DB_SQLITE_FILE: "/data/database.sqlite"

# Uncomment this if IPv6 is not enabled on your host
# DISABLE_IPV6: 'true'

volumes:
- ./data:/data
- ./letsencrypt:/etc/letsencrypt

Grüße
Anonymous User

 

[An0nym3]

Hallo,

du kannst in docker-compose-files existierende Netzwerke referenzieren. Danach kannst du den Container einfach über den hostnamen ansprechen. Da dein MySQL-Server schon im Netzwerk "syncing_server" ist, könntest du das verwenden. Theoretisch müsstest du einfach zu deinem nginx-docker-compose folgenden block hinzufügen:

networks:
syncing_server:
external:
name: syncing_server

und dem nginx-service dann einfach darauf referenzieren lassen:

services:
app:
...
networks:
syncing_server:

Theoretisch würde das funktionieren (ich habs noch nicht probiert, sieht bei meinen compose files aber ähnlich aus ), ich würde aber dringend dazu raten, ein eigenes Netzwerk zu nutzen. Mach beispielsweise im compose-file mit der Datenbank ein eigenes Netzwerk nur für die Datenbank und referenziere nur die Services, die auch wirklich die Datenbank nutzen. Oder noch besser: Wenn du den MySQL-Server wirklich für mehrere Services verwenden willst, extrahiere ihn in ein eigenes compose-file - so bist du flexibler.

Aus Erfahrung kann ich dir aber auch raten, wenn du genügend Ressourcen hast, mach dir einen eigenen MySQL-Server für jeden Service. Dann musst du dir bei Updates von einem MySQL-Server keine Gedanken machen, ob alle anderen Services das verkraften werden

 

[Anonymous User]

Danke für die Antwort! Dann werde ich wohl für jeden Dienst einen eigenen Datenbankserver einrichten.

Eine Frage hätte ich noch, ich dachte man erstellt Compose Files nur, wenn man vor hat, mehrere Container zusammenzufügen?

Spoiler: Yacht Docker Beispiel

docker volume create yacht
docker run -d -p 8000:8000 -v /var/run/docker.sock:/var/run/docker.sock -v yacht:/config --name yacht selfhostedpro/yacht

wird hier auch eine Datei, ähnlich wie die docker-compose.yml, erstellt, wo ich Einstellungen vornehmen kann?

Spoiler: Yacht Compose Beispiel

version: "3"
services:
yacht:
container_name: yacht
restart: unless-stopped
ports:
- 8000:8000
volumes:
- yacht:/config
- /var/run/docker.sock:/var/run/docker.sock
image: selfhostedpro/yacht

volumes:
yacht:

 

[An0nym3]

Das orchestrieren von mehreren Diensten ist nur eine gute Eigenschaft von docker-compose. Eine andere ist, dass das ganze System für eine Servicelandschaft in einer "verarbeitbaren-Datei" steht. Die kann man einfach nehmen und überall anders in einem Schritt wieder ausführen (im Bullshitbingo nennt man das "IAC - Infrastructure as Code"). Da spielt es keine Rolle ob nur ein Service drinnen steht oder mehrere - deshalb würde ich immer alles in compose dateien machen.

Docker arbeitet im hintergrund ganz anders, da weiß ich selbst nicht genau wie
Wenn man aber bestehende container abändern will, kann man das entweder über die CLI oder über eine REST-API machen. Alternativ natürlich auch über einen UI-Service wie Portainer (für Anfänger sehr zu empfehlen), da gibts aber noch etliche alternativen

 

[Anonymous User]

alles klar, danke dir für die Antwort.

Portainer nutze ich auch. Wobei zurzeit überwiegend Yacht, ist meiner Meinung nach noch bisschen übersichtlicher.

 

[Skysnake]

Im Prinzip wurde ja alles schon gesagt. Du separierst durch die Netzwerke den Zugriff. Die Datenbank hängt nur an internen Netzen und der NGINX an intern + extern. Wenn jemand also auf die Datenbank zugreifen will muss er über den nginx, der das aber je nachdem nicht zulässt.

Eine goldene Practice ist es nur die Container ins gleiche Netz zu packen, die auch wirklich miteinander reden müssen. Werden dann zwar eventuell einige Netze, aber das macht ja kaum Arbeit.