it-swarm.com.de

Wie konfiguriere ich die Docker-Portzuordnung für die Verwendung von Nginx als Upstream-Proxy?

Update II

Es ist jetzt der 16. Juli 2015 und die Dinge haben sich wieder geändert. Ich habe diesen automagischen Container von Jason Wilder entdeckt: https://github.com/jwilder/nginx-proxy und er löst dieses Problem in ungefähr so ​​langer Zeit Es dauert bis docker run der Container. Dies ist jetzt die Lösung, die ich verwende, um dieses Problem zu lösen.

Aktualisieren

Es ist jetzt Juli 2015 und die Dinge haben sich in Bezug auf die Vernetzung von Docker-Containern drastisch geändert. Mittlerweile gibt es viele verschiedene Angebote, die dieses Problem auf verschiedene Weise lösen.

Sie sollten diesen Beitrag verwenden, um ein grundlegendes Verständnis des docker --link - Ansatzes für die Dienstermittlung zu erlangen, der so einfach wie möglich ist, sehr gut funktioniert und tatsächlich erforderlich ist weniger ausgefallen als die meisten anderen Lösungen. Es ist insofern begrenzt, als es ziemlich schwierig ist, Container auf separaten Hosts in einem bestimmten Cluster zu vernetzen. Container können nach dem Vernetzen nicht neu gestartet werden, bieten jedoch eine schnelle und relativ einfache Möglichkeit, Container auf demselben Host zu vernetzen. Auf diese Weise können Sie sich einen Eindruck davon verschaffen, mit welcher Software Sie dieses Problem wahrscheinlich lösen.

Darüber hinaus möchten Sie wahrscheinlich auch Dockers aufkommende network , Hashicorps consul überprüfen. ), Weaveworks weave , Jeff Lindsays progrium/consul & gliderlabs/registrator und Googles Kubernetes .

Es gibt auch die CoreOS -Angebote, die etcd , fleet und flannel .

Und wenn Sie wirklich eine Party haben möchten, können Sie einen Cluster aufrüsten, um Mesosphere oder Deis auszuführen. oder Flynn .

Wenn Sie neu im Networking sind (wie ich), sollten Sie Ihre Lesebrille herausholen und "Malen Sie den Himmel mit Sternen - Das Beste von Enya" auf dem Wi-Hi anzeigen -Fi, und ein Bier knacken - es wird eine Weile dauern, bis Sie wirklich genau verstehen, was Sie versuchen zu tun. Hinweis: Sie versuchen, einen Service Discovery Layer in Ihrem Cluster Control Plane zu implementieren. Es ist eine sehr schöne Art, einen Samstagabend zu verbringen.

Es macht sehr viel Spaß, aber ich wünschte, ich hätte mir die Zeit genommen, mich besser über das Networking im Allgemeinen zu informieren, bevor ich direkt eintauchte. Schließlich fand ich ein paar Beiträge der wohlwollenden Digital Ocean Tutorial-Götter: Introduction to Networking Terminology und Understanding ... Networking . Ich empfehle, diese zuerst einige Male zu lesen, bevor Sie eintauchen.

Habe Spaß!



Ursprünglicher Beitrag

Ich kann die Portzuordnung für Docker -Container nicht verstehen. Speziell, wie Anforderungen von Nginx an einen anderen Container weitergeleitet werden, der an einem anderen Port auf demselben Server empfangsbereit ist.

Ich habe eine Docker-Datei für einen Nginx-Container wie folgt:

FROM ubuntu:14.04
MAINTAINER Me <[email protected]>

RUN apt-get update && apt-get install -y htop git nginx

ADD sites-enabled/api.myapp.com /etc/nginx/sites-enabled/api.myapp.com
ADD sites-enabled/app.myapp.com /etc/nginx/sites-enabled/app.myapp.com
ADD nginx.conf /etc/nginx/nginx.conf

RUN echo "daemon off;" >> /etc/nginx/nginx.conf

EXPOSE 80 443

CMD ["service", "nginx", "start"]



Und dann sieht die api.myapp.com Konfigurationsdatei so aus:

upstream api_upstream{

    server 0.0.0.0:3333;

}


server {

    listen 80;
    server_name api.myapp.com;
    return 301 https://api.myapp.com/$request_uri;

}


server {

    listen 443;
    server_name api.mypp.com;

    location / {

        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $Host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_pass http://api_upstream;

    }

}

Und dann noch eine für app.myapp.com.

Und dann laufe ich:

Sudo docker run -p 80:80 -p 443:443 -d --name Nginx myusername/nginx


Und alles steht gut, aber die Anfragen werden nicht an die anderen Container/Häfen weitergeleitet. Und wenn ich in den Nginx-Container ssh und die Protokolle inspiziere, sehe ich keine Fehler.

Irgendeine Hilfe?

81
AJB

@T0xicCodes Antwort ist richtig, aber ich dachte, ich würde die Details erweitern, da ich tatsächlich ungefähr 20 Stunden brauchte, um endlich eine funktionierende Lösung zu implementieren.

Wenn Sie Nginx in einem eigenen Container ausführen und es als Reverse-Proxy zum Lastenausgleich mehrerer Anwendungen auf derselben Serverinstanz verwenden möchten, müssen Sie die folgenden Schritte ausführen:

Verlinken Sie Ihre Container

Wenn Sie Ihre Container docker runEN, indem Sie normalerweise ein Shell-Skript in User Data eingeben, können Sie Verknüpfungen zu anderen Containern running deklarieren. Dies bedeutet, dass Sie Ihre Container in der richtigen Reihenfolge starten müssen und nur die letzteren Container mit den ersteren verknüpfen können. Wie so:

#!/bin/bash
Sudo docker run -p 3000:3000 --name API mydockerhub/api
Sudo docker run -p 3001:3001 --link API:API --name App mydockerhub/app
Sudo docker run -p 80:80 -p 443:443 --link API:API --link App:App --name Nginx mydockerhub/nginx

In diesem Beispiel ist der Container API nicht mit anderen verknüpft, aber der Container App ist mit API verknüpft, und Nginx ist sowohl mit API als auch mit App verknüpft.

Das Ergebnis davon sind Änderungen an den env-Variablen und den /etc/hosts-Dateien, die sich in den Containern API und App befinden. Die Ergebnisse sehen so aus:

/etc/hosts

Wenn Sie cat /etc/hosts in Ihrem Container Nginx ausführen, erhalten Sie Folgendes:

172.17.0.5  0fd9a40ab5ec
127.0.0.1   localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.3  App
172.17.0.2  API



ENV Vars

Wenn Sie env in Ihrem Container Nginx ausführen, erhalten Sie Folgendes:

API_PORT=tcp://172.17.0.2:3000
API_PORT_3000_TCP_PROTO=tcp
API_PORT_3000_TCP_PORT=3000
API_PORT_3000_TCP_ADDR=172.17.0.2

APP_PORT=tcp://172.17.0.3:3001
APP_PORT_3001_TCP_PROTO=tcp
APP_PORT_3001_TCP_PORT=3001
APP_PORT_3001_TCP_ADDR=172.17.0.3

Ich habe viele der tatsächlichen Variablen abgeschnitten, aber die oben genannten sind die Schlüsselwerte, die Sie für die Übertragung von Datenverkehr an Ihre Container benötigen.

Verwenden Sie Folgendes, um eine Shell zum Ausführen der obigen Befehle in einem laufenden Container zu erhalten:

Sudo docker exec -i -t Nginx bash

Sie können sehen, dass Sie jetzt sowohl /etc/hosts-Dateieinträge als auch env-Variablen haben, die die lokale IP-Adresse für jeden der verknüpften Container enthalten. Soweit ich das beurteilen kann, ist dies alles, was passiert, wenn Sie Container mit deklarierten Verknüpfungsoptionen ausführen. Sie können diese Informationen jetzt jedoch verwenden, um nginx in Ihrem Nginx-Container zu konfigurieren.



Konfigurieren von Nginx

Hier wird es etwas knifflig und es gibt ein paar Möglichkeiten. Sie können Ihre Sites so konfigurieren, dass sie auf einen Eintrag in der /etc/hosts-Datei verweisen, die docker erstellt hat, oder Sie können die vars ENV verwenden und einen String-Ersatz (ich habe sed verwendet) für Ihren nginx.conf und alle anderen conf-Dateien ausführen, die sich möglicherweise in Ihrem befinden /etc/nginx/sites-enabled Ordner zum Einfügen der IP-Werte.



OPTION A: Konfigurieren Sie Nginx mit ENV Vars

Dies ist die Option, die ich gewählt habe, weil ich die /etc/hosts-Dateioption nicht zum Laufen bekommen habe. Ich werde Option B früh genug ausprobieren und diesen Beitrag mit allen Ergebnissen aktualisieren.

Der Hauptunterschied zwischen dieser Option und der Verwendung der /etc/hosts-Dateioption besteht darin, wie Sie Ihren Dockerfile schreiben, um ein Shell-Skript als CMD-Argument zu verwenden, das wiederum die Ersetzung der Zeichenfolge zum Kopieren der IP-Werte von ENV in Ihre conf-Datei (en) behandelt.

Hier sind die Konfigurationsdateien, mit denen ich gelandet bin:

Dockerfile

FROM ubuntu:14.04
MAINTAINER Your Name <[email protected]>

RUN apt-get update && apt-get install -y nano htop git nginx

ADD nginx.conf /etc/nginx/nginx.conf
ADD api.myapp.conf /etc/nginx/sites-enabled/api.myapp.conf
ADD app.myapp.conf /etc/nginx/sites-enabled/app.myapp.conf
ADD Nginx-Startup.sh /etc/nginx/Nginx-Startup.sh

EXPOSE 80 443

CMD ["/bin/bash","/etc/nginx/Nginx-Startup.sh"]

nginx.conf

daemon off;
user www-data;
pid /var/run/nginx.pid;
worker_processes 1;


events {
    worker_connections 1024;
}


http {

    # Basic Settings

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 33;
    types_hash_max_size 2048;

    server_tokens off;
    server_names_hash_bucket_size 64;

    include /etc/nginx/mime.types;
    default_type application/octet-stream;


    # Logging Settings
    access_log /var/log/nginx/access.log;
    error_log /var/log/nginx/error.log;


    # Gzip Settings

gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 3;
    gzip_buffers 16 8k;
    gzip_http_version 1.1;
    gzip_types text/plain text/xml text/css application/x-javascript application/json;
    gzip_disable "MSIE [1-6]\.(?!.*SV1)";

    # Virtual Host Configs  
    include /etc/nginx/sites-enabled/*;

    # Error Page Config
    #error_page 403 404 500 502 /srv/Splash;


}

HINWEIS: Es ist wichtig, daemon off; in Ihre nginx.conf-Datei aufzunehmen, um sicherzustellen, dass Ihr Container nicht sofort nach dem Start beendet wird.

api.myapp.conf

upstream api_upstream{
    server APP_IP:3000;
}

server {
    listen 80;
    server_name api.myapp.com;
    return 301 https://api.myapp.com/$request_uri;
}

server {
    listen 443;
    server_name api.myapp.com;

    location / {
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $Host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_pass http://api_upstream;
    }

}

Nginx-Startup.sh

#!/bin/bash
sed -i 's/APP_IP/'"$API_PORT_3000_TCP_ADDR"'/g' /etc/nginx/sites-enabled/api.myapp.com
sed -i 's/APP_IP/'"$APP_PORT_3001_TCP_ADDR"'/g' /etc/nginx/sites-enabled/app.myapp.com

service nginx start

Ich überlasse es Ihnen, Ihre Hausaufgaben für die meisten Inhalte von nginx.conf und api.myapp.conf zu machen.

Die Magie findet in Nginx-Startup.sh statt, wo wir sed verwenden, um die Zeichenfolge für den APP_IP-Platzhalter zu ersetzen, den wir in den upstream-Block unserer api.myapp.conf- und app.myapp.conf-Dateien geschrieben haben.

Diese ask.ubuntu.com-Frage erklärt es sehr gut: Suchen und Ersetzen von Text in einer Datei mithilfe von Befehlen

[~ # ~] gotcha [~ # ~] Unter OSX behandelt sed Optionen unterschiedlich, insbesondere das Flag -i. Unter Ubuntu behandelt das Flag -i das Ersetzen 'an Ort und Stelle'. Es wird die Datei öffnen, den Text ändern und dann über dieselbe Datei 'speichern'. Unter OSX ist das Flag -i erfordert die Dateierweiterung, die die resultierende Datei haben soll. Wenn Sie mit einer Datei ohne Erweiterung arbeiten, müssen Sie '' als Wert für das Flag -i eingeben.

[~ # ~] gotcha [~ # ~] Um ENV-Variablen in der Regex zu verwenden, die sed verwendet, um die Zeichenfolge zu finden, die Sie ersetzen möchten, müssen Sie Schließen Sie den var in doppelte Anführungszeichen ein. Die korrekte, wenn auch wackelig aussehende Syntax ist also wie oben.

Deshalb hat docker unseren Container gestartet und das Skript Nginx-Startup.sh gestartet, das sed verwendet, um den Wert APP_IP in die entsprechende Variable ENV zu ändern, die wir im Befehl sed angegeben haben. In unserem Verzeichnis /etc/nginx/sites-enabled befinden sich jetzt conf-Dateien mit den IP-Adressen der Variablen ENV, die der Docker beim Starten des Containers festgelegt hat. In Ihrer api.myapp.conf-Datei wird der Block upstream folgendermaßen geändert:

upstream api_upstream{
    server 172.0.0.2:3000;
}

Die IP-Adresse, die Sie sehen, kann unterschiedlich sein, aber ich habe festgestellt, dass es normalerweise 172.0.0.x ist.

Sie sollten jetzt alles Routing entsprechend haben.

[~ # ~] gotcha [~ # ~] Sie können keine Container neu starten/erneut ausführen, nachdem Sie den Start der ersten Instanz ausgeführt haben. Docker versieht jeden Container beim Start mit einer neuen IP und scheint keine der zuvor verwendeten IPs wiederzuverwenden. api.myapp.com erhält also zum ersten Mal 172.0.0.2, zum nächsten Mal 172.0.0.4. Aber Nginx hat bereits die erste IP in seinen conf-Dateien oder in seiner /etc/hosts-Datei festgelegt, sodass die neue IP für api.myapp.com nicht ermittelt werden kann. Die Lösung für dieses Problem wird wahrscheinlich CoreOS und seinen etcd-Dienst verwenden, der nach meinem eingeschränkten Verständnis wie ein gemeinsamer ENV für alle Maschinen funktioniert, die in demselben CoreOS-Cluster registriert sind. Dies ist das nächste Spielzeug, mit dem ich spielen werde.



OPTION B: /etc/hosts-Dateieinträge verwenden

Dies sollte ist der schnellere und einfachere Weg, dies zu tun, aber ich konnte es nicht zum Laufen bringen. Angeblich haben Sie nur den Wert des /etc/hosts-Eintrags in Ihre api.myapp.conf- und app.myapp.conf-Dateien eingegeben, aber ich konnte diese Methode nicht zum Laufen bringen.

UPDATE: Anweisungen zum Ausführen dieser Methode finden Sie unter @ Wes Tods Antwort .

Hier ist der Versuch, den ich in api.myapp.conf gemacht habe:

upstream api_upstream{
    server API:3000;
}

Wenn man bedenkt, dass es einen Eintrag in meiner /etc/hosts-Datei gibt, der so aussieht: 172.0.0.2 API Ich dachte, es würde nur den Wert einbringen, aber es scheint nicht so zu sein.

Ich hatte auch ein paar zusätzliche Probleme mit meinem Elastic Load Balancer-Sourcing von allen AZ, sodass dies möglicherweise das Problem war, als ich diese Route ausprobierte. Stattdessen musste ich lernen, wie man unter Linux mit dem Ersetzen von Strings umgeht. Das hat Spaß gemacht. Ich werde es in einer Weile versuchen und sehen, wie es geht.

55
AJB

Ich habe versucht, den beliebten Reverse-Proxy von Jason Wilder zu verwenden, der auf magische Weise für alle funktioniert, und dabei festgestellt, dass er nicht für alle funktioniert (dh für mich). Und ich bin brandneu in NGINX und mochte es nicht, dass ich die Technologien, die ich verwenden wollte, nicht verstand.

Wollte meine 2 Cent hinzufügen, da die Diskussion über linking Container jetzt veraltet ist, da es sich um ein veraltetes Feature handelt. Hier ist eine Erklärung, wie das mit networks gemacht wird. Diese Antwort ist ein vollständiges Beispiel für das Einrichten von nginx als Reverse-Proxy für eine statisch ausgelagerte Website unter Verwendung von Docker Compose Und der Konfiguration von nginx.

TL; DR;

Fügen Sie die Dienste, die miteinander kommunizieren müssen, zu einem vordefinierten Netzwerk hinzu. Für eine schrittweise Diskussion über Docker-Netzwerke habe ich hier einige Dinge gelernt: https://technologyconversations.com/2016/04/25/docker-networking-and-dns-the-good-the- böse und hässlich /

Definieren Sie das Netzwerk

Zunächst benötigen wir ein Netzwerk, über das alle Ihre Backend-Services kommunizieren können. Ich habe mein web angerufen, aber es kann sein, was immer du willst.

docker network create web

Erstellen Sie die App

Wir machen einfach eine einfache Website-App. Die Website ist eine einfache index.html-Seite, die von einem Nginx-Container bereitgestellt wird. Der Inhalt ist ein bereitgestelltes Volume auf dem Host unter einem Ordner content

DockerFile:

FROM nginx
COPY default.conf /etc/nginx/conf.d/default.conf

default.conf

server {
    listen       80;
    server_name  localhost;

    location / {
        root   /var/www/html;
        index  index.html index.htm;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

docker-compose.yml

version: "2"

networks:
  mynetwork:
    external:
      name: web

services:
  nginx:
    container_name: sample-site
    build: .
    expose:
      - "80"
    volumes:
      - "./content/:/var/www/html/"
    networks:
      default: {}
      mynetwork:
        aliases:
          - sample-site

Beachten Sie, dass wir hier keine Portzuordnung mehr benötigen. Wir legen einfach Port 80 offen. Dies ist praktisch, um Portkollisionen zu vermeiden.

Führen Sie die App aus

Starten Sie diese Website mit

docker-compose up -d

Einige lustige Überprüfungen der DNS-Zuordnungen für Ihren Container:

docker exec -it sample-site bash
ping sample-site

Dieser Ping sollte in Ihrem Container funktionieren.

Erstellen Sie den Proxy

Nginx Reverse Proxy:

Dockerfile

FROM nginx

RUN rm /etc/nginx/conf.d/*

Wir setzen die gesamte Konfiguration des virtuellen Hosts zurück, da wir sie anpassen werden.

docker-compose.yml

version: "2"

networks:
  mynetwork:
    external:
      name: web


services:
  nginx:
    container_name: nginx-proxy
    build: .
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./conf.d/:/etc/nginx/conf.d/:ro
      - ./sites/:/var/www/
    networks:
      default: {}
      mynetwork:
        aliases:
          - nginx-proxy

Führen Sie den Proxy aus

Starten Sie den Proxy mit unserem Trusty

docker-compose up -d

Unter der Annahme, dass keine Probleme vorliegen, werden zwei Container ausgeführt, die unter Verwendung ihrer Namen miteinander kommunizieren können. Lass es uns testen.

docker exec -it nginx-proxy bash
ping sample-site
ping nginx-proxy

Richten Sie den virtuellen Host ein

Das letzte Detail ist das Einrichten der virtuellen Hosting-Datei, damit der Proxy den Datenverkehr basierend darauf leiten kann, wie Sie Ihren Abgleich einrichten möchten:

sample-site.conf für unsere virtuelle Hosting-Konfiguration:

  server {
    listen 80;
    listen [::]:80;

    server_name my.domain.com;

    location / {
      proxy_pass http://sample-site;
    }

  }

Je nachdem, wie der Proxy eingerichtet wurde, muss diese Datei in Ihrem lokalen Ordner conf.d Gespeichert werden, den wir über die volumes -Deklaration in der Datei docker-compose Eingehängt haben.

Zu guter Letzt weisen Sie nginx an, die Konfiguration neu zu laden.

docker exec nginx-proxy service nginx reload

Diese Abfolge von Schritten ist der Höhepunkt stundenlanger Kopfschmerzen, als ich mit dem immer wieder schmerzhaften 502 Bad Gateway-Fehler kämpfte und zum ersten Mal Nginx lernte, seit ich den größten Teil meiner Erfahrung mit Apache hatte.

Diese Antwort soll zeigen, wie der 502 Bad Gateway-Fehler behoben wird, der dadurch verursacht wird, dass Container nicht miteinander kommunizieren können.

Ich hoffe, diese Antwort erspart jemandem stundenlangen Schmerz, da es aus irgendeinem Grund sehr schwer war, Container zum Reden zu bringen, obwohl ich dies für einen offensichtlichen Anwendungsfall hielt. Aber andererseits, ich dumm. Und lassen Sie mich bitte wissen, wie ich diesen Ansatz verbessern kann.

11
gdbj

Mit Docker-Links können Sie den Upstream-Container mit dem Nginx-Container verknüpfen. Ein zusätzliches Feature ist, dass Docker die Host-Datei verwaltet, was bedeutet, dass Sie auf den verknüpften Container mit einem Namen verweisen können und nicht mit der potenziell zufälligen IP-Adresse.

9
T0xicCode

AJBs "Option B" funktioniert, wenn Sie das Ubuntu-Basis-Image verwenden und Nginx selbst einrichten. (Es hat nicht funktioniert, als ich das Nginx-Image von Docker Hub verwendet habe.)

Hier ist die Docker-Datei, die ich verwendet habe:

FROM ubuntu
RUN apt-get update && apt-get install -y nginx
RUN ln -sf /dev/stdout /var/log/nginx/access.log
RUN ln -sf /dev/stderr /var/log/nginx/error.log
RUN rm -rf /etc/nginx/sites-enabled/default
EXPOSE 80 443
COPY conf/mysite.com /etc/nginx/sites-enabled/mysite.com
CMD ["nginx", "-g", "daemon off;"]

Meine Nginx-Konfiguration (aka: conf/mysite.com):

server {
    listen 80 default;
    server_name mysite.com;

    location / {
        proxy_pass http://website;
    }
}

upstream website {
    server website:3000;
}

Und zum Schluss, wie ich meine Container starte:

$ docker run -dP --name website website
$ docker run -dP --name nginx --link website:website nginx

Dies brachte mich zum Laufen, so dass mein Nginx den Stromaufwärts zu dem zweiten Andockcontainer zeigte, der den Port 3000 freilegte.

7
Wes Todd

Die Antwort von @gdbj ist eine großartige Erklärung und die aktuellste Antwort. Hier ist jedoch ein einfacherer Ansatz.

Wenn Sie also den gesamten Datenverkehr von nginx, der 80 Abhört, zu einem anderen Container umleiten möchten, der 8080 Verfügbar macht, kann die Mindestkonfiguration so gering wie:

nginx.conf:

server {
    listen 80;

    location / {
        proxy_pass http://client:8080; # this one here
        proxy_redirect off;
    }

}

docker-compose.yml

version: "2"
services:
  entrypoint:
    image: some-image-with-nginx
    ports:
      - "80:80"
    links:
      - client  # will use this one here

  client:
    image: some-image-with-api
    ports:
      - "8080:8080"

Docker-Dokumente

6
Diolor

Habe gerade einen Artikel von Anand Mani Sankar gefunden, der eine einfache Möglichkeit zeigt, Nginx Upstream Proxy mit Docker Composer zu verwenden.

Grundsätzlich muss man die Instanzverknüpfung und die Ports in der Docker-Compose-Datei konfigurieren und die Upstream-Version in der Datei nginx.conf entsprechend aktualisieren.

2
lsborg