Mise à jour II

Nous sommes maintenant le 16 juillet 2015 et les choses ont de nouveau changé. J'ai découvert ce conteneur automagique de Jason Wilder : https://github.com/jwilder/nginx-proxyet il résout ce problème en autant de temps qu'il faut pour docker runle conteneur. C'est maintenant la solution que j'utilise pour résoudre ce problème.

Mise à jour

Nous sommes maintenant en juillet 2015 et les choses ont radicalement changé en ce qui concerne la mise en réseau des conteneurs Docker. Il existe maintenant de nombreuses offres différentes qui résolvent ce problème (de différentes manières).

Vous devriez utiliser cet article pour acquérir une compréhension de base de l' docker --linkapproche de la découverte de services, qui est à peu près aussi basique que possible, fonctionne très bien et nécessite en fait moins de danse sophistiquée que la plupart des autres solutions. Il est limité en ce sens qu'il est assez difficile de mettre en réseau des conteneurs sur des hôtes distincts dans un cluster donné, et les conteneurs ne peuvent pas être redémarrés une fois mis en réseau, mais offrent un moyen rapide et relativement simple de mettre en réseau des conteneurs sur le même hôte. C'est un bon moyen d'avoir une idée de ce que le logiciel que vous utiliserez probablement pour résoudre ce problème fait réellement sous le capot.

De plus, vous aurez probablement envie de vérifier également Docker de la naissante network, Hashicorp de consul, Weaveworks weave, Jeff Lindsay progrium/consul&gliderlabs/registrator et Google Kubernetes.

Il y a aussi les CoreOS offres qui utilisent etcd, fleetet flannel.

Et si vous voulez vraiment organiser une fête, vous pouvez créer un cluster pour exécuter Mesosphere, ou Deis, ou Flynn.

Si vous êtes nouveau dans le réseautage (comme moi), vous devriez sortir vos lunettes de lecture, pop "Paint The Sky With Stars - The Best of Enya" sur le Wi-Hi-Fi et craquer une bière - ça va être un moment avant de vraiment comprendre exactement ce que vous essayez de faire. Astuce: vous essayez d'implémenter un Service Discovery Layerdans votre Cluster Control Plane. C'est une très belle façon de passer un samedi soir.

C'est très amusant, mais j'aurais aimé prendre le temps de mieux me renseigner sur le réseautage en général avant de me lancer directement. J'ai finalement trouvé quelques articles des dieux bienveillants du Digital Ocean Tutorial: Introduction to Networking Terminologyet Understanding ... Networking. Je suggère de les lire quelques fois avant de plonger.

S'amuser!

Message original

Je n'arrive pas à comprendre le mappage des ports pour les Dockerconteneurs. Plus précisément, comment passer des requêtes de Nginx à un autre conteneur, en écoutant sur un autre port, sur le même serveur.

J'ai un Dockerfile pour un conteneur Nginx comme ceci:

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"]

Et puis le api.myapp.comfichier de configuration ressemble à ceci:

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;

    }

}

Et puis un autre pour app.myapp.comaussi.

Et puis je cours:

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

Et tout se tient très bien, mais les demandes ne sont pas transmises aux autres conteneurs / ports. Et quand je ssh dans le conteneur Nginx et inspecter les journaux, je ne vois aucune erreur.

De l'aide?

La réponse de @ T0xicCode est correcte, mais j'ai pensé développer les détails car il m'a fallu environ 20 heures pour enfin mettre en place une solution fonctionnelle.

Si vous cherchez à exécuter Nginx dans son propre conteneur et à l'utiliser comme proxy inverse pour équilibrer la charge de plusieurs applications sur la même instance de serveur, les étapes à suivre sont les suivantes:

Liez vos conteneurs

Lorsque vous utilisezdocker run vos conteneurs, généralement en entrant un script shell dans User Data, vous pouvez déclarer des liens vers tout autre conteneur en cours d' exécution . Cela signifie que vous devez démarrer vos conteneurs dans l'ordre et que seuls les derniers conteneurs peuvent être liés aux premiers. Ainsi:

#!/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

Ainsi, dans cet exemple, le APIconteneur n'est lié à aucun autre, mais le Appconteneur est lié à APIet Nginxest lié à la fois à APIet App.

Il en résulte des modifications apportées aux envvariables vars et aux /etc/hostsfichiers qui résident dans les conteneurs APIet App. Les résultats ressemblent à ceci:

/ etc / hosts

L'exécution cat /etc/hostsdans votre Nginxconteneur produira les éléments suivants:

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

L'exécution envdans votre Nginxconteneur produira les éléments suivants:

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

J'ai tronqué la plupart des variables réelles, mais les valeurs ci-dessus sont les valeurs clés dont vous avez besoin pour transférer le trafic vers vos conteneurs.

Pour obtenir un shell pour exécuter les commandes ci-dessus dans un conteneur en cours d'exécution, utilisez ce qui suit:

sudo docker exec -i -t Nginx bash

Vous pouvez voir que vous disposez désormais à la fois d' /etc/hostsentrées de fichier et de envvariables contenant l'adresse IP locale de l'un des conteneurs liés. Autant que je sache, c'est tout ce qui se passe lorsque vous exécutez des conteneurs avec des options de lien déclarées. Mais vous pouvez maintenant utiliser ces informations pour configurer nginxdans votre Nginxconteneur.

Configurer Nginx

C'est là que ça devient un peu compliqué, et il y a quelques options. Vous pouvez choisir de configurer vos sites pour pointer vers une entrée dans le /etc/hostsfichier qui a dockercréé, ou vous pouvez utiliser les ENVvars et exécuter un remplacement de chaîne (j'ai utilisé sed) sur votre nginx.confet tout autre fichier de configuration qui peut être dans votre /etc/nginx/sites-enableddossier pour insérer l'adresse IP valeurs.

OPTION A: Configurer Nginx à l'aide d'ENV Vars

C'est l'option que j'ai choisie car je ne pouvais pas faire fonctionner l' /etc/hostsoption de fichier. Je vais essayer l'option B assez tôt et mettre à jour cet article avec les résultats.

La principale différence entre cette option et l'utilisation de l' /etc/hostsoption de fichier réside dans la façon dont vous écrivez votre Dockerfilepour utiliser un script shell comme CMDargument, qui à son tour gère le remplacement de chaîne pour copier les valeurs IP ENVdans vos fichiers de configuration.

Voici l'ensemble des fichiers de configuration avec lesquels j'ai fini:

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;


}

REMARQUE: il est important de l'inclure daemon off;dans votre nginx.conffichier pour vous assurer que votre conteneur ne se ferme pas immédiatement après son lancement.

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

Je vous laisse le soin de faire vos devoirs sur la plupart des contenus de nginx.confet api.myapp.conf.

La magie se produit Nginx-Startup.shlà où nous utilisons sedpour faire le remplacement de chaîne sur l' APP_IPespace réservé que nous avons écrit dans le upstreambloc de nos fichiers api.myapp.confet app.myapp.conf.

Cette question de ask.ubuntu.com l'explique très bien: rechercher et remplacer du texte dans un fichier à l'aide de commandes

GOTCHA Sous OSX, sedgère les options différemment, le -idrapeau en particulier. Sur Ubuntu, le -idrapeau gérera le remplacement «en place»; il ouvrira le fichier, changera le texte, puis «sauvegardera» le même fichier. Sous OSX, l' -iindicateur nécessite l'extension de fichier que vous souhaitez que le fichier résultant ait. Si vous travaillez avec un fichier sans extension, vous devez saisir «» comme valeur pour l' -iindicateur.

GOTCHA Pour utiliser ENV vars dans l'expression régulière qui sedutilise pour trouver la chaîne que vous voulez remplacer, vous devez mettre la var entre guillemets. Ainsi, la syntaxe correcte, quoique d'aspect bancal, est celle ci-dessus.

Ainsi, docker a lancé notre conteneur et déclenché l' Nginx-Startup.shexécution du script, qui a utilisé sedpour changer la valeur APP_IPde la ENVvariable correspondante que nous avons fournie dans la sedcommande. Nous avons maintenant des fichiers de configuration dans notre /etc/nginx/sites-enabledrépertoire qui ont les adresses IP des ENVvariables que le docker a définies lors du démarrage du conteneur. Dans votre api.myapp.conffichier, vous verrez que le upstreambloc a changé comme suit:

upstream api_upstream{
    server 172.0.0.2:3000;
}

L'adresse IP que vous voyez peut être différente, mais j'ai remarqué que c'est généralement le cas 172.0.0.x.

Vous devriez maintenant avoir tout routé correctement.

GOTCHA Vous ne pouvez redémarrer / réexécuter aucun conteneur une fois que vous avez exécuté le lancement initial de l'instance. Docker fournit à chaque conteneur une nouvelle adresse IP lors du lancement et ne semble pas réutiliser celle qui était utilisée auparavant. Donc api.myapp.comobtiendra 172.0.0.2 la première fois, mais ensuite 172.0.0.4 la prochaine fois. Mais Nginxaura déjà défini la première adresse IP dans ses fichiers de configuration, ou dans son /etc/hostsfichier, il ne pourra donc pas déterminer la nouvelle adresse IP pour api.myapp.com. La solution à cela est susceptible d'utiliser CoreOSet de son etcdservice qui, dans ma compréhension limitée, agit comme un partage ENVpour toutes les machines enregistrées dans le même CoreOScluster. C'est le prochain jouet avec lequel je vais jouer.

OPTION B: utiliser les /etc/hostsentrées de fichier

Cela devrait être le moyen le plus rapide et le plus simple de le faire, mais je n'ai pas pu le faire fonctionner. Apparemment, vous entrez simplement la valeur de l' /etc/hostsentrée dans vos fichiers api.myapp.confet app.myapp.conf, mais je n'ai pas pu faire fonctionner cette méthode.

MISE À JOUR: Voir la réponse de @Wes Tod pour savoir comment faire fonctionner cette méthode.

Voici la tentative que j'ai faite api.myapp.conf:

upstream api_upstream{
    server API:3000;
}

Compte tenu du fait qu'il y a une entrée dans mon /etc/hostsfichier comme ceci: 172.0.0.2 APIje pensais que cela extrairait simplement la valeur, mais cela ne semble pas l'être.

J'ai également eu quelques problèmes accessoires avec mon Elastic Load Balancerapprovisionnement de tous les AZ, c'est peut-être le problème lorsque j'ai essayé cette route. Au lieu de cela, j'ai dû apprendre à gérer le remplacement des chaînes sous Linux, donc c'était amusant. Je vais essayer dans un moment et voir comment ça se passe.

J'ai essayé d'utiliser le proxy inverse populaire de Jason Wilder qui fonctionne comme par magie pour tout le monde, et j'ai appris que cela ne fonctionne pas pour tout le monde (c'est-à-dire moi). Et je suis tout nouveau sur NGINX et je n'ai pas aimé le fait que je ne comprenais pas les technologies que j'essayais d'utiliser.

Je voulais ajouter mes 2 cents, car la discussion ci-dessus sur les linkingconteneurs ensemble est maintenant datée car il s'agit d'une fonctionnalité obsolète. Alors, voici une explication sur la façon de le faire en utilisant networks. Cette réponse est un exemple complet de configuration de nginx en tant que proxy inverse vers un site Web paginé statiquement à l'aide d'une Docker Composeconfiguration nginx.

TL, DR;

Ajoutez les services qui doivent se parler sur un réseau prédéfini. Pour une discussion étape par étape sur les réseaux Docker, j'ai appris certaines choses ici: https://technologyconversations.com/2016/04/25/docker-networking-and-dns-the-good-the-bad-and- le moche/

Définir le réseau

Tout d'abord, nous avons besoin d'un réseau sur lequel tous vos services backend peuvent communiquer. J'ai appelé le mien webmais ça peut être ce que tu veux.

docker network create web

Construisez l'application

Nous allons simplement créer une application de site Web simple. Le site Web est une simple page index.html servie par un conteneur nginx. Le contenu est un volume monté sur l'hôte sous un dossiercontent

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

Notez que nous n'avons plus besoin de mappage de port ici. Nous exposons simplement le port 80. Ceci est pratique pour éviter les collisions de ports.

Lancez l'application

Lancez ce site Web avec

docker-compose up -d

Quelques vérifications amusantes concernant les mappages DNS pour votre conteneur:

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

Ce ping devrait fonctionner, à l'intérieur de votre conteneur.

Construire le proxy

Proxy inverse Nginx:

Dockerfile

FROM nginx

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

Nous réinitialisons toute la configuration de l'hôte virtuel, car nous allons la personnaliser.

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

Exécutez le proxy

Lancez le proxy en utilisant notre fidèle

docker-compose up -d

En supposant qu'il n'y ait aucun problème, vous avez deux conteneurs en cours d'exécution qui peuvent se parler en utilisant leurs noms. Testons-le.

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

Configurer l'hôte virtuel

Le dernier détail consiste à configurer le fichier d'hébergement virtuel afin que le proxy puisse diriger le trafic en fonction de la manière dont vous souhaitez configurer votre correspondance:

sample-site.conf pour notre configuration d'hébergement virtuel:

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

    server_name my.domain.com;

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

  }

En fonction de la configuration du proxy, vous aurez besoin de ce fichier stocké dans votre conf.ddossier local que nous avons monté via la volumesdéclaration dans le docker-composefichier.

Enfin, dites à nginx de recharger sa configuration.

docker exec nginx-proxy service nginx reload

Cette séquence d'étapes est le point culminant d'heures de maux de tête alors que je luttais contre l'erreur toujours douloureuse 502 Bad Gateway et que j'apprenais nginx pour la première fois, car la plupart de mon expérience était avec Apache.

Cette réponse consiste à montrer comment éliminer l'erreur 502 Bad Gateway qui résulte du fait que les conteneurs ne peuvent pas se parler.

J'espère que cette réponse permettra à quelqu'un d'économiser des heures de douleur, car il était vraiment difficile de faire en sorte que les conteneurs se parlent pour une raison quelconque, bien que ce soit ce que je m'attendais à être un cas d'utilisation évident. Mais là encore, moi stupide. Et faites-moi savoir comment je peux améliorer cette approche.

À l'aide de liens docker , vous pouvez lier le conteneur en amont au conteneur nginx. Une fonctionnalité supplémentaire est que le docker gère le fichier hôte, ce qui signifie que vous pourrez faire référence au conteneur lié en utilisant un nom plutôt que l'adresse IP potentiellement aléatoire.

L '"Option B" d'AJB peut être mise en œuvre en utilisant l'image Ubuntu de base et en configurant nginx vous-même. (Cela n'a pas fonctionné lorsque j'ai utilisé l'image Nginx de Docker Hub.)

Voici le fichier Docker que j'ai utilisé:

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;"]

Ma configuration nginx (alias: conf / mysite.com):

server {
    listen 80 default;
    server_name mysite.com;

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

upstream website {
    server website:3000;
}

Et enfin, comment je démarre mes conteneurs:

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

Cela m'a mis en marche, donc mon nginx a pointé l'amont vers le deuxième conteneur docker qui exposait le port 3000.

La réponse de @ gdbj est une excellente explication et la réponse la plus à jour. Voici cependant une approche plus simple.

Donc, si vous souhaitez rediriger tout le trafic de nginx écoutant 80vers un autre conteneur exposant 8080, la configuration minimale peut être aussi petite que:

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"

Documents Docker

Je viens de trouver un article d'Anand Mani Sankar qui montre un moyen simple d'utiliser le proxy amont nginx avec docker composer.

Fondamentalement, il faut configurer la liaison d'instance et les ports dans le fichier docker-compose et mettre à jour en amont sur nginx.conf en conséquence.