Update II

Es ist jetzt der 16. Juli 2015 und die Dinge haben sich wieder geändert. Ich habe diesen automatischen Container von Jason Wilder entdeckt : https://github.com/jwilder/nginx-proxyund er löst dieses Problem in ungefähr so ​​langer Zeit, wie er für docker runden Container benötigt wird. Dies ist jetzt die Lösung, mit der ich dieses Problem löse.

Aktualisieren

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

Sie sollten diesen Beitrag verwenden, um ein grundlegendes Verständnis des docker --linkAnsatzes zur Serviceerkennung zu erlangen , der so grundlegend wie möglich ist, sehr gut funktioniert und tatsächlich weniger ausgefallenes Tanzen erfordert 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, und Container können nach dem Netzwerk nicht neu gestartet werden, bieten jedoch eine schnelle und relativ einfache Möglichkeit, Container auf demselben Host zu vernetzen. Dies ist eine gute Möglichkeit, sich ein Bild davon zu machen, was die Software, mit der Sie dieses Problem wahrscheinlich lösen werden, tatsächlich unter der Haube tut.

Darüber hinaus sollten Sie sich wahrscheinlich auch Docker's network, Hashicorp's consul, Weaveworks weave, Jeff Lindsay's progrium/consul&gliderlabs/registrator und Google's ansehen Kubernetes.

Es gibt auch die CoreOS Angebote , die zu nutzen etcd, fleetund flannel.

Und wenn Sie wirklich eine Party haben möchten, können Sie einen Cluster zum Ausführen starten Mesosphere, oder Deis, oder Flynn.

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

Es macht 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 von den wohlwollenden Göttern des Digital Ocean Tutorial: Introduction to Networking Terminologyund Understanding ... Networking. Ich schlage vor, diese zuerst ein paar Mal zu lesen, bevor ich eintauche.

Habe Spaß!

Ursprünglicher Beitrag

Ich kann die Portzuordnung für DockerContainer nicht verstehen . Insbesondere, wie Anforderungen von Nginx an einen anderen Container übergeben werden, der einen anderen Port auf demselben Server überwacht.

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 api.myapp.comsieht die 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 renne 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 / Ports weitergeleitet. Und wenn ich in den Nginx-Container ssh und die Protokolle inspiziere, sehe ich keine Fehler.

Irgendeine Hilfe?

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

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

Verknüpfen Sie Ihre Container

Wenn Sie docker runIhre Container verwenden, in der Regel durch Eingabe eines Shell-Skripts User Data, können Sie Links zu anderen laufenden Containern deklarieren . Dies bedeutet, dass Sie Ihre Container in der richtigen Reihenfolge starten müssen und nur die letzteren Container mit den ersteren verknüpft werden 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

So in diesem Beispiel das APIwird Behälter aller anderen nicht verbunden, aber der AppBehälter verknüpft ist APIund Nginxauf beide verbunden APIund App.

Das Ergebnis sind Änderungen an den envVariablen und /etc/hostsDateien, die sich in den Containern APIund befinden App. Die Ergebnisse sehen so aus:

/ etc / hosts

Wenn Sie cat /etc/hostsin Ihrem NginxContainer ausgeführt werden, wird Folgendes erzeugt:

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 envin Ihrem NginxContainer ausgeführt werden, wird Folgendes erzeugt:

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 benötigen, um den Datenverkehr auf Ihre Container zu übertragen.

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

sudo docker exec -i -t Nginx bash

Sie können sehen, dass Sie jetzt sowohl /etc/hostsDateieinträge als auch envVariablen haben, die die lokale IP-Adresse für einen der verknüpften Container enthalten. Soweit ich das beurteilen kann, ist dies alles, was passiert, wenn Sie Container mit deklarierten Linkoptionen ausführen. Sie können diese Informationen jetzt jedoch zum Konfigurieren nginxin Ihrem NginxContainer verwenden.

Nginx konfigurieren

Hier wird es etwas knifflig und es gibt einige Möglichkeiten. Sie können Ihre Sites so konfigurieren, dass sie auf einen Eintrag in der erstellten /etc/hostsDatei verweisen docker, oder Sie können die ENVvars verwenden und einen String-Ersatz (den ich verwendet habe sed) für Ihre nginx.confund alle anderen conf-Dateien ausführen, die sich möglicherweise in Ihrem /etc/nginx/sites-enabledOrdner befinden, um die IP einzufügen Werte.

OPTION A: Konfigurieren Sie Nginx mit ENV Vars

Dies ist die Option, die ich gewählt habe, weil ich die Dateioption nicht /etc/hostszum Laufen bringen konnte. 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/hostsDateioption besteht darin, wie Sie schreiben Dockerfile, um ein Shell-Skript als CMDArgument zu verwenden, das wiederum das Ersetzen der Zeichenfolge zum Kopieren der IP-Werte ENVin Ihre Conf-Datei (en) übernimmt.

Hier sind die Konfigurationsdateien, mit denen ich am Ende fertig war:

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, diese daemon off;in Ihre nginx.confDatei 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 über die meisten Inhalte von nginx.confund zu machen api.myapp.conf.

Die Magie entsteht dort, Nginx-Startup.shwo wir sedden APP_IPPlatzhalter, den wir in den geschrieben haben, durch Zeichenfolgen ersetzenupstream Block unserer api.myapp.confund 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 Behandelt unter OSX sedOptionen unterschiedlich, insbesondere das -iFlag. Unter Ubuntu -iübernimmt das Flag den Ersatz "an Ort und Stelle". Es öffnet die Datei, ändert den Text und speichert dieselbe Datei. Unter OSX erfordert das -iFlag die Dateierweiterung, die die resultierende Datei haben soll. Wenn Sie mit einer Datei ohne Erweiterung arbeiten, müssen Sie '' als Wert für das eingeben-i Flag eingeben.

GOTCHA Um ENV-Variablen innerhalb des regulären Ausdrucks zu verwendensed mit dem die zu ersetzende Zeichenfolge gefunden wird, müssen Sie die in doppelte Anführungszeichen setzen. Die korrekte, wenn auch wackelig aussehende Syntax lautet also wie oben.

Daher hat Docker unseren Container gestartet und die Nginx-Startup.shAusführung des Skripts ausgelöst , mit dem sedder Wert APP_IPin die entsprechende ENVVariable geändert wurde , die wir im sedBefehl angegeben haben. Wir haben jetzt conf-Dateien in unserem /etc/nginx/sites-enabledVerzeichnis, die die IP-Adressen der ENVVariablen enthalten, die Docker beim Starten des Containers festgelegt hat. In Ihrer api.myapp.confDatei sehen Sie, dass sich der upstreamBlock wie folgt geändert hat:

upstream api_upstream{
    server 172.0.0.2:3000;
}

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

Sie sollten jetzt alles entsprechend routen.

GOTCHA Sie können keine Container neu starten / erneut ausführen, sobald Sie den ersten Instanzstart ausgeführt haben. Docker stellt jedem Container beim Start eine neue IP-Adresse zur Verfügung und scheint keine zuvor verwendete IP-Adresse wiederzuverwenden. So api.myapp.comwird beim ersten Mal 172.0.0.2, beim nächsten Mal 172.0.0.4. Aber Nginxwird bereits die erste IP in seine conf - Dateien festgelegt, oder in seiner /etc/hostsDatei, so wird es nicht möglich sein , für die neue IP zu bestimmen api.myapp.com. Die Lösung hierfür wird wahrscheinlich CoreOSund ihr etcdDienst verwendet, der nach meinem begrenzten Verständnis ENVfür alle im selben CoreOSCluster registrierten Computer wie eine gemeinsame Lösung fungiert . Dies ist das nächste Spielzeug, mit dem ich spielen werde.

OPTION B: Verwenden Sie /etc/hostsDateieinträge

Dies sollte der schnellere und einfachere Weg sein, aber ich konnte es nicht zum Laufen bringen. Angeblich haben Sie nur den Wert des /etc/hostsEintrags in Ihre api.myapp.confund app.myapp.confDateien eingegeben , aber ich konnte diese Methode nicht zum Laufen bringen.

UPDATE: Siehe die Antwort von @Wes Tod für Anweisungen, wie diese Methode funktioniert.

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

upstream api_upstream{
    server API:3000;
}

In Anbetracht dessen, dass es einen Eintrag in meinem gibt /etc/hosts Datei wie den folgenden enthält: 172.0.0.2 APIIch dachte, er würde nur den Wert abrufen, aber es scheint nicht so zu sein.

Ich hatte auch ein paar zusätzliche Probleme mit meiner Elastic Load BalancerBeschaffung von allen AZs, so dass 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, also hat das Spaß gemacht. Ich werde es gleich versuchen und sehen, wie es geht.

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

Wollte meine 2 Cent hinzufügen, da die obige Diskussion über linkingContainer zusammen jetzt veraltet ist, da es sich um eine veraltete Funktion handelt. Hier ist eine Erklärung, wie es geht networks. Diese Antwort ist ein vollständiges Beispiel für das Einrichten von nginx als Reverse-Proxy für eine statisch ausgelagerte Website mit Docker Composeund nginx-Konfiguration.

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-bad-and- das hässliche/

Definieren Sie das Netzwerk

Zunächst benötigen wir ein Netzwerk, über das alle Ihre Backend-Services kommunizieren können. Ich habe meine angerufen, webaber es kann sein, was immer Sie wollen.

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 für den Host bereitgestelltes Volume unter einem Ordnercontent

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 Port 80 einfach frei. 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 bezüglich 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 besteht darin, die virtuelle Hosting-Datei so einzurichten, dass 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;
    }

  }

Abhängig davon, wie der Proxy eingerichtet wurde, benötigen Sie diese Datei in Ihrem lokalen conf.dOrdner, den wir über die volumesDeklaration in der Datei bereitgestellt habendocker-compose Datei bereitgestellt 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 schmerzhaften 502 Bad Gateway-Fehler kämpfte und zum ersten Mal Nginx lernte, da der größte Teil meiner Erfahrung mit Apache war.

Diese Antwort soll zeigen, wie der 502 Bad Gateway-Fehler behoben werden kann, der darauf zurückzuführen ist, dass Container nicht miteinander kommunizieren können.

Ich hoffe, diese Antwort erspart jemandem da draußen stundenlange Schmerzen, da es aus irgendeinem Grund sehr schwierig war, Container dazu zu bringen, miteinander zu sprechen, obwohl dies ein offensichtlicher Anwendungsfall war. Aber andererseits bin ich dumm. Und bitte lassen Sie mich wissen, wie ich diesen Ansatz verbessern kann.

Mithilfe von Docker-Links können Sie den Upstream-Container mit dem Nginx-Container verknüpfen. Eine zusätzliche Funktion ist, dass Docker die Hostdatei verwaltet. Dies bedeutet, dass Sie auf den verknüpften Container mit einem Namen und nicht mit der potenziell zufälligen IP verweisen können.

AJBs "Option B" kann mithilfe des Ubuntu-Basisimages und der Einrichtung von nginx selbst zum Laufen gebracht werden. (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 schließlich, 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, sodass mein Nginx den Upstream auf den zweiten Docker-Container richtete, der Port 3000 freilegte.

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 umleiten möchten, während ein 80anderer Container verfügbar gemacht wird 8080, kann die Mindestkonfiguration so gering sein 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

Ich 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 den Upstream unter nginx.conf entsprechend aktualisieren.