TOC

So hosten Sie mehrere Websites mit Nginx und HAProxy mit LXD unter Ubuntu 16.04

Einführung

Ein Linux-Container ist eine Gruppierung von Prozessen, die durch die Verwendung von Linux-Kernel-Sicherheitsfunktionen wie Namespaces und Kontrollgruppen vom Rest des Systems isoliert ist. Es ist ein Konstrukt ähnlich einer virtuellen Maschine, aber viel leichter. Sie müssen keinen zusätzlichen Kernel ausführen oder die Hardware simulieren. Dies bedeutet, dass Sie problemlos mehrere Container auf demselben Server erstellen können. Mit Linux-Containern können Sie mehrere Instanzen ganzer Betriebssysteme auf demselben Server ausführen oder Ihre Anwendung und ihre Abhängigkeiten in einem Container bündeln, ohne den Rest des Systems zu beeinträchtigen.

Stellen Sie sich beispielsweise vor, Sie haben einen Server und mehrere Dienste, einschließlich Websites, für Ihre Kunden eingerichtet. In einer herkömmlichen Installation ist jede Website ein virtueller Host derselben Instanz des Apache- oder Nginx-Webservers. Bei Linux-Containern wird jedoch jede Website in einem eigenen Container mit einem eigenen Webserver konfiguriert.

Wir können LXD verwenden, um diese Container zu erstellen und zu verwalten. LXD bietet einen Hypervisor-Service zur Verwaltung des gesamten Lebenszyklus von Containern.

In diesem Lernprogramm installieren Sie mit LXD zwei Nginx-basierte Websites auf demselben Server, von denen jede auf einen eigenen Container beschränkt ist. Dann installieren Sie HAProxy in einem dritten Container, der als Reverse-Proxy fungiert. Anschließend leiten Sie den Datenverkehr an den HAProxy-Container weiter, um beide Websites über das Internet zugänglich zu machen.

Voraussetzungen

Um dieses Lernprogramm abzuschließen, benötigen Sie Folgendes:

Schritt 1 - Hinzufügen Ihres Benutzers zur Gruppe "+ lxd +"

Melden Sie sich mit dem Nicht-Root-Benutzerkonto beim Server an. Wir werden dieses Nichtbenutzerkonto verwenden, um alle Container-Verwaltungsaufgaben auszuführen. Damit dies funktioniert, müssen Sie diesen Benutzer zuerst der Gruppe "+ lxd +" hinzufügen. Tun Sie dies mit dem folgenden Befehl:

sudo usermod --append --groups lxd

Melden Sie sich vom Server ab und wieder an, damit Ihre neue SSH-Sitzung mit der neuen Gruppenmitgliedschaft aktualisiert wird. Sobald Sie angemeldet sind, können Sie mit der Konfiguration von LXD beginnen.

Schritt 2 - LXD konfigurieren

LXD muss ordnungsgemäß konfiguriert sein, bevor Sie es verwenden können. Die wichtigste Konfigurationsentscheidung ist die Art des Speicher-Backends zum Speichern der Container. Das empfohlene Speicher-Backend für LXD ist das ZFS-Dateisystem, das entweder in einer vorab zugewiesenen Datei oder unter Verwendung von Block Storage gespeichert wird. Um die ZFS-Unterstützung in LXD zu verwenden, installieren Sie das Paket + zfsutils-linux +:

sudo apt-get update
sudo apt-get install zfsutils-linux

Wenn das installiert ist, können Sie LXD initialisieren. Während der Initialisierung werden Sie aufgefordert, die Details für das ZFS-Speicher-Backend anzugeben. Es folgen zwei Abschnitte, je nachdem, ob Sie eine vorab zugewiesene Datei oder einen Blockspeicher verwenden möchten. Befolgen Sie die entsprechenden Schritte für Ihren Fall. Nachdem Sie den Speichermechanismus festgelegt haben, konfigurieren Sie die Netzwerkoptionen für Ihre Container.

Option 1 - Verwenden einer vorab zugewiesenen Datei

Führen Sie die folgenden Schritte aus, um LXD für die Verwendung einer vorab zugewiesenen Datei zum Speichern von Containern zu konfigurieren. Führen Sie zunächst den folgenden Befehl aus, um den LXD-Initialisierungsprozess zu starten:

sudo lxd init

Sie werden aufgefordert, mehrere Informationen anzugeben, wie in der folgenden Ausgabe gezeigt. Wir wählen alle Standardeinstellungen aus, einschließlich der vorgeschlagenen Größe für die vorab zugewiesene Datei, die als * loop device * bezeichnet wird:

OutputName of the storage backend to use (dir or zfs) [default=zfs]:
Create a new ZFS pool (yes/no) [default=yes]?
Name of the new ZFS pool [default=lxd]:
Would you like to use an existing block device (yes/no) [default=no]?
Size in GB of the new loop device (1GB minimum) [default=15]:
Would you like LXD to be available over the network (yes/no) [default=no]?
Do you want to configure the LXD bridge (yes/no) [default=yes]?
Warning: Stopping lxd.service, but it can still be activated by:
 lxd.socket
LXD has been successfully configured.

Die vorgeschlagene Größe wird automatisch aus dem verfügbaren Speicherplatz Ihres Servers berechnet.

Sobald das Gerät konfiguriert ist, konfigurieren Sie die Netzwerkeinstellungen, die wir nach dem nächsten optionalen Abschnitt untersuchen.

Option 2 - Verwenden des Blockspeichers

Wenn Sie Block Storage verwenden möchten, müssen Sie das Gerät suchen, das auf das von Ihnen erstellte Block Storage-Volume verweist, um es in der Konfiguration von LXD anzugeben. Gehen Sie zur Registerkarte * Volumes * im https://cloud.digitalocean.com [DigitalOcean-Kontrollbereich] l, suchen Sie Ihr Volume, klicken Sie auf das Popup * More * und klicken Sie dann auf * Config Instructions *.

Suchen Sie das Gerät, indem Sie den Befehl zum Formatieren des Volumes aufrufen. Suchen Sie insbesondere nach dem Pfad, der im Befehl + sudo mkfs.ext4 -F + angegeben ist. Die folgende Abbildung zeigt ein Beispiel für die Lautstärke. Sie benötigen nur den unterstrichenen Teil:

image: https: //assets.digitalocean.com/articles/lxd_containers_ubuntu_1604/6rDyC1l.png [Die Konfigurationsanweisungen zeigen das Gerät für den erstellten Blockspeicher.]

In diesem Fall lautet der Name des Datenträgers "+ / dev / disk / by-id / scsi-0D0_Volume_volume-fra1-01 +", obwohl Ihr Name davon abweichen kann.

Wenn Sie das Volume identifiziert haben, kehren Sie zu Ihrem Terminal zurück und geben Sie den folgenden Befehl ein, um den LXD-Initialisierungsprozess zu starten.

sudo lxd init

Sie werden mit einer Reihe von Fragen konfrontiert. Beantworten Sie die Fragen wie in der folgenden Ausgabe gezeigt:

OutputName of the storage backend to use (dir or zfs) [default=zfs]:
Create a new ZFS pool (yes/no) [default=yes]?
Name of the new ZFS pool [default=lxd]:

Wenn Sie aufgefordert werden, ein vorhandenes Blockgerät zu verwenden, wählen Sie "+ yes +" und geben Sie den Pfad zu Ihrem Gerät an:

Output of the "lxd init" commandWould you like to use an existing block device (yes/no) [default=no]?
Path to the existing block device:

Verwenden Sie dann den Standardwert für die verbleibenden Fragen:

Output of the "lxd init" commandWould you like LXD to be available over the network (yes/no) [default=no]?
Do you want to configure the LXD bridge (yes/no) [default=yes]?
Warning: Stopping lxd.service, but it can still be activated by:
 lxd.socket
LXD has been successfully configured.

Sobald der Vorgang abgeschlossen ist, konfigurieren Sie das Netzwerk.

Netzwerk konfigurieren

Während des Initialisierungsprozesses sehen Sie eine Reihe von Bildschirmen wie in der folgenden Abbildung, in denen Sie die Netzwerkbrücke für die Container konfigurieren können, damit diese private IP-Adressen abrufen, miteinander kommunizieren und auf das Internet zugreifen können.

image: https://assets.digitalocean.com/articles/lxd_containers_ubuntu_1604/u9D79uB.png [LXD-Netzwerkkonfiguration]

Verwenden Sie für jede Option den Standardwert. Wenn Sie jedoch nach IPv6-Netzwerken gefragt werden, wählen Sie "Nein", da wir diesen Wert in diesem Lernprogramm nicht verwenden werden.

Sobald Sie die Netzwerkkonfiguration abgeschlossen haben, können Sie Ihre Container erstellen.

Schritt 3 - Erstellen von Containern

Wir haben LXD erfolgreich konfiguriert. Wir haben den Speicherort des Speicher-Backends angegeben und das Standardnetzwerk für neu erstellte Container konfiguriert. Wir sind bereit, einige Container zu erstellen und zu verwalten, die wir mit dem Befehl "+ lxc +" ausführen.

Probieren wir unseren ersten Befehl aus, der die verfügbaren installierten Container auflistet:

lxc list

Sie sehen die folgende Ausgabe:

Output of the "lxd list" commandGenerating a client certificate. This may take a minute...
If this is your first time using LXD, you should also run: sudo lxd init
To start your first container, try: lxc launch ubuntu:16.04

+------+-------+------+------+------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+------+-------+------+------+------+-----------+

Da dies das erste Mal ist, dass der Befehl "+ lxc +" mit dem LXD-Hypervisor kommuniziert, zeigt die Ausgabe an, dass der Befehl automatisch ein Client-Zertifikat für die sichere Kommunikation mit LXD erstellt hat. Anschließend werden einige Informationen zum Starten eines Containers angezeigt. Schließlich zeigt der Befehl eine leere Liste von Containern an, was zu erwarten ist, da wir noch keine erstellt haben.

Erstellen wir drei Container. Wir erstellen einen für jeden Webserver und einen dritten Container für den Reverse-Proxy. Der Zweck des Reverse-Proxys besteht darin, eingehende Verbindungen aus dem Internet an den richtigen Webserver im Container zu leiten.

Wir werden den Befehl + lxc launch + verwenden, um einen Ubuntu 16.04-Container (+ ubuntu: x +) mit dem Namen + web1 + zu erstellen und zu starten. Das + x + in + ubuntu: x + ist eine Abkürzung für den ersten Buchstaben von Xenial, dem Codenamen von Ubuntu 16.04. + ubuntu: + ist die Kennung für das vorkonfigurierte Repository von LXD-Images.

Führen Sie die folgenden Befehle aus, um die Container zu erstellen:

lxc launch ubuntu:x web1
lxc launch ubuntu:x web2
lxc launch ubuntu:x haproxy

Da wir zum ersten Mal einen Container erstellt haben, lädt der erste Befehl das Container-Image aus dem Internet herunter und speichert es lokal im Cache. Die nächsten beiden Container werden deutlich schneller erstellt.

Hier sehen Sie die Beispielausgabe der Erstellung des Containers "+ web1 +".

OutputCreating web1
Retrieving image: 100%
Starting web1

Nachdem wir drei leere Vanille-Container erstellt haben, verwenden wir den Befehl "+ lxc list +", um Informationen darüber anzuzeigen:

lxc list

Die Ausgabe zeigt eine Tabelle mit dem Namen jedes Containers, seinem aktuellen Status, seiner IP-Adresse, seinem Typ und ob Momentaufnahmen gemacht wurden.

Ausgabe

+---------+---------+-----------------------+------+------------+-----------+
|  NAME   |  STATE  |         IPV4          | IPV6 |    TYPE    | SNAPSHOTS |
+---------+---------+-----------------------+------+------------+-----------+
| haproxy | RUNNING | 10.10.10.10 (eth0)    |      | PERSISTENT | 0         |
+---------+---------+-----------------------+------+------------+-----------+
| web1    | RUNNING | 10.10.10.100 (eth0)   |      | PERSISTENT | 0         |
+---------+---------+-----------------------+------+------------+-----------+
| web2    | RUNNING | 10.10.10.200 (eth0)   |      | PERSISTENT | 0         |
+---------+---------+-----------------------+------+------------+-----------+

Notieren Sie sich die Containernamen und die zugehörige IPv4-Adresse. Sie benötigen sie, um Ihre Dienste zu konfigurieren.

Schritt 4 - Konfigurieren der Nginx-Container

Stellen Sie eine Verbindung zum Container "+ web1 +" her und konfigurieren Sie den ersten Webserver.

Um eine Verbindung herzustellen, verwenden wir den Befehl "+ lxc exec +", der den Namen des Containers und die auszuführenden Befehle enthält. Führen Sie den folgenden Befehl aus, um eine Verbindung zum Container herzustellen:

lxc exec web1 -- sudo --login --user ubuntu

Die Zeichenfolge "+ - " gibt an, dass die Befehlsparameter für " lxc " dort enden sollen, und der Rest der Zeile wird als Befehl übergeben, der im Container ausgeführt werden soll. Der Befehl lautet " sudo --login --user ubuntu " und bietet eine Anmeldeshell für das vorkonfigurierte Konto " ubuntu +" im Container.

Einmal im Container, sieht unsere Shell-Eingabeaufforderung nun wie folgt aus.

Outputubuntu@web1:~$

Dieser * ubuntu * -Benutzer im Container hat einen vorkonfigurierten "+ sudo " -Zugriff und kann " sudo +" -Befehle ausführen, ohne ein Kennwort anzugeben. Diese Hülle ist innerhalb der Grenzen des Behälters begrenzt. Alles, was wir in dieser Shell ausführen, bleibt im Container und kann nicht zum Hostserver fliehen.

Aktualisieren wir die Paketliste der Ubuntu-Instanz im Container und installieren Nginx:

sudo apt-get update
sudo apt-get install nginx

Bearbeiten Sie die Standardwebseite für diese Site und fügen Sie Text hinzu, der verdeutlicht, dass diese Site im Container "+ web1 " gehostet wird. Öffnen Sie die Datei " / var / www / html / index.nginx-debian.html":

sudo nano /var/www/html/index.nginx-debian.html

Nehmen Sie die folgende Änderung an der Datei vor:

Bearbeitete Datei /var/www/html/index.nginx-debian.html

<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx !</title>
<style>
   body {
       width: 35em;
       margin: 0 auto;
       font-family: Tahoma, Verdana, Arial, sans-serif;
   }
</style>
</head>
<body>
<h1>Welcome to nginx !</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
...

Wir haben die Datei an zwei Stellen bearbeitet und den Text "+" im LXD-Container "web1 +" hinzugefügt. Speichern Sie die Datei und beenden Sie Ihren Editor.

Melden Sie sich jetzt vom Container ab und kehren Sie zum Host-Server zurück:

logout

Wiederholen Sie diesen Vorgang für den Container "+ web2 ". Melden Sie sich an, installieren Sie Nginx und bearbeiten Sie die Datei " / var / www / html / index.nginx-debian.html ", um " web2 " zu erwähnen. Dann verlassen Sie den Container ` web2 +`.

Verwenden wir "+ curl +", um zu testen, ob die Webserver in den Containern funktionieren. Wir benötigen die IP-Adressen der zuvor angezeigten Webcontainer.

curl http://10.10.10.100/

Die Ausgabe sollte sein:

Output of "curl http://10.10.10.100/" command<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx !</title>
<style>
   body {
       width: 35em;
       margin: 0 auto;
       font-family: Tahoma, Verdana, Arial, sans-serif;
   }
</style>
</head>
<body>
<h1>Welcome to nginx !</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
...

Testen Sie auch den zweiten Container mit dem Befehl "+ curl +" und seiner IP-Adresse, um sicherzustellen, dass er auch richtig eingerichtet ist. Wenn beide Container konfiguriert sind, können wir mit der Einrichtung von HAProxy fortfahren.

Schritt 5 - Konfigurieren des HAProxy-Containers

Wir richten HAProxy als Proxy vor diesen Containern ein. Wenn Sie weitere Informationen zur Funktionsweise benötigen, lesen Sie das Tutorial Eine Einführung in HAProxy und Load Balancing Konzepte. Wir leiten den Datenverkehr zu jedem Container basierend auf dem von uns verwendeten Domainnamen weiter. Im folgenden Konfigurationsbeispiel verwenden wir die Domain "+ example.com ", eine https://tools.ietf.org/html/rfc2606[special reserved domain] für die Dokumentation wie dieses Tutorial. Wir stellen die erste Website unter den Hostnamen " example.com " und " www.example.com " zur Verfügung. Die zweite Website befindet sich unter " www2.example.com +". Ersetzen Sie diese Domainnamen durch Ihre eigenen Domainnamen.

Loggen Sie sich in den + haproxy + Container ein:

lxc exec haproxy -- sudo --login --user ubuntu

Aktualisieren Sie die Liste der Installationspakete und installieren Sie HAProxy:

sudo apt-get update
sudo apt-get install haproxy

Sobald die Installation abgeschlossen ist, können wir HAProxy konfigurieren. Die Konfigurationsdatei für HAProxy befindet sich unter + / etc / haproxy / haproxy.cfg +. Öffnen Sie die Datei mit Ihrem bevorzugten Texteditor.

sudo nano /etc/haproxy/haproxy.cfg

Zunächst nehmen wir einige Änderungen am Abschnitt "+ Defaults " vor. Wir fügen die Option " forwardfor " hinzu, um die reale Quell-IP des Webclients beizubehalten, und wir fügen die Option " http-server-close +" hinzu, die die Wiederverwendung von Sitzungen und eine geringere Latenz ermöglicht.

/etc/haproxy/haproxy.conf

global
...
defaults
   log global
   mode    http
   option  httplog
   option  dontlognull


   timeout connect 5000
   timeout client  50000
   timeout server  50000
...

Als Nächstes konfigurieren wir das Frontend so, dass es auf unsere beiden Backend-Container verweist. Fügen Sie einen neuen Abschnitt + frontend + mit dem Namen + www_frontend + hinzu, der so aussieht:

/etc/haproxy/haproxy.conf

        # Bind to port 80 (www) on the container

   # It matches if the HTTP Host: field mentions any of the hostnames (after the '-i').



   # Redirect the connection to the proper server cluster, depending on the match.

Die Befehle "+ acl " stimmen mit den Hostnamen der Webserver überein und leiten die Anforderungen an den entsprechenden Abschnitt " backend +" weiter.

Dann definieren wir zwei neue "+ Backend " - Abschnitte, einen für jeden Webserver, und benennen sie " web1_cluster " bzw. " web2_cluster +". Fügen Sie der Datei den folgenden Code hinzu, um die Backends zu definieren:

/etc/haproxy/haproxy.conf

   # We set the X-Client-IP HTTP header. This is useful if we want the web server to know the real client IP.

   # This backend, named here "web1", directs to container "web1.lxd" (hostname).

Die Option "+ balance " bezeichnet die Lastausgleichsstrategie. In diesem Fall entscheiden wir uns für die geringste Anzahl von Verbindungen. Die Option " http-request" setzt einen HTTP-Header mit der realen Web-Client-IP. Wenn wir diesen Header nicht setzen, zeichnet der Webserver die HAProxy-IP-Adresse als Quell-IP für alle Verbindungen auf, wodurch es schwieriger wird zu analysieren, woher Ihr Datenverkehr stammt. Die Option "+ server " gibt einen beliebigen Namen für den Server an (" web1 +"), gefolgt von dem Hostnamen und dem Port des Servers.

LXD stellt einen DNS-Server für die Container bereit, daher wird "+ web1.lxd " in die IP aufgelöst, die dem " web1 " - Container zugeordnet ist. Die anderen Container haben ihre eigenen Hostnamen, z. B. " web2.lxd " und " haproxy.lxd +".

Der Parameter "+ check +" weist HAPRoxy an, Integritätsprüfungen auf dem Webserver durchzuführen, um sicherzustellen, dass er verfügbar ist.

Führen Sie den folgenden Befehl aus, um zu testen, ob die Konfiguration gültig ist:

/usr/sbin/haproxy -f /etc/haproxy/haproxy.cfg -c

Die Ausgabe sollte sein

Ausgabe

Configuration file is valid

Laden Sie HAProxy neu, damit die neue Konfiguration gelesen wird.

sudo systemctl reload haproxy

Melden Sie sich jetzt aus dem Container ab, um zum Host zurückzukehren.

logout

Wir haben HAProxy so konfiguriert, dass es als Reverse-Proxy fungiert, der alle Verbindungen, die es an Port "+ 80 " empfängt, an den entsprechenden Webserver in den beiden anderen Containern weiterleitet. Testen wir, dass " haproxy +" es tatsächlich schafft, die Anforderungen an den richtigen Webcontainer weiterzuleiten. Führen Sie diesen Befehl aus:

curl --verbose --header 'Host: web2.example.com' http://10.10.10.10

Dadurch wird eine Anforderung an HAProxy gesendet und ein HTTP-Header "+ host +" festgelegt, den HAProxy verwenden soll, um die Verbindung zum entsprechenden Webserver umzuleiten.

Die Ausgabe sollte sein

Output of "curl --verbose --header 'Host: web2.example.com' http://10.10.10.10" command...
> GET / HTTP/1.1
> Host:
> User-Agent: curl/7.47.0
> Accept: */*
>
...
<
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx !</title>
<style>
...

HAProxy hat die Anfrage richtig verstanden und an den Container + web2 + weitergeleitet. Dort stellte der Webserver die zuvor bearbeitete Standard-Indexseite bereit und zeigt den Text "+" im LXD-Container "web2 +" an. Lassen Sie uns nun externe Anfragen an HAProxy weiterleiten, damit die Welt auf unsere Websites zugreifen kann.

Schritt 6 - Weiterleiten eingehender Verbindungen an den HAProxy-Container

Der letzte Teil des Puzzles besteht darin, den Reverse-Proxy mit dem Internet zu verbinden. Wir müssen unseren Server so einrichten, dass alle Verbindungen, die er aus dem Internet über den Port "+ 80 " empfängt, an den Container " haproxy +" weitergeleitet werden.

HAProxy ist in einem Container installiert und standardmäßig nicht über das Internet erreichbar. Um dies zu lösen, erstellen wir eine "+ iptables +" - Regel, um Verbindungen weiterzuleiten.

Der Befehl "+ iptables +" erfordert zwei IP-Adressen: die öffentliche IP-Adresse des Servers ("") und die private IP-Adresse des "+ haproxy +" - Containers (""), die Sie mit "" erhalten können + lxc liste + `befehl.

Führen Sie diesen Befehl aus, um die Regel zu erstellen:

sudo iptables -t nat -I PREROUTING -i eth0 -p TCP -d /32 --dport 80 -j DNAT --to-destination :80

So funktioniert der Befehl:

  • "+ -t nat " gibt an, dass wir die " nat +" - Tabelle verwenden.

  • "+ -I PREROUTING +" gibt an, dass die Regel der PREROUTING-Kette hinzugefügt wird.

  • + -i eth0 + gibt die Schnittstelle * eth0 * an, die die öffentliche Standardschnittstelle für Droplets ist.

  • "+ -p TCP +" besagt, dass wir das TCP-Protokoll verwenden.

  • + -d / 32 + gibt die Ziel-IP-Adresse für die Regel an.

  • + - dport 80 +: Gibt den Zielport an.

  • + -j DNAT + sagt aus, dass wir zu Destination NAT (DNAT) springen wollen.

  • + - to-destination: 80 + gibt an, dass die Anforderung mit HAProxy an die IP-Adresse des Containers gesendet werden soll.

Weitere Informationen zu IPTables finden Sie unter How the Iptables Firewall Works und https://www.digitalocean.com/community/tutorials/ iptables-essentials-allgemeine-Firewall-Regeln-und-Befehle [IPtables Essentials: Allgemeine Firewall-Regeln und -Befehle].

Um diesen Befehl "+ iptables " zu speichern, damit er nach einem Neustart erneut angewendet wird, installieren wir das Paket " iptables-persistent +":

sudo apt-get install iptables-persistent

Bei der Installation des Pakets werden Sie aufgefordert, die aktuellen iptables-Regeln zu speichern. Akzeptiere und speichere alle aktuellen "+ iptables +" Regeln.

Wenn Sie die beiden FQDNs eingerichtet haben, sollten Sie in der Lage sein, mit Ihrem Webbrowser eine Verbindung zu jeder Website herzustellen. Versuch es.

Um zu testen, ob die beiden Webserver tatsächlich über das Internet erreichbar sind, greifen Sie von Ihrem lokalen Computer aus mit dem Befehl "+ curl +" auf die beiden Server zu:

curl --verbose --header 'Host: example.com' 'http://'
curl --verbose --header 'Host: web2.example.com' 'http://'

Diese Befehle stellen HTTP-Verbindungen zur öffentlichen IP-Adresse des Servers her und fügen ein HTTP-Header-Feld mit der Option "+ - Header +" hinzu, mit der HAProxy die Anforderung wie in Schritt 5 behandelt.

Hier ist die Ausgabe des ersten "+ curl +" - Befehls:

Output*   Trying ...
* Connected to  () port 80 (#0)
> GET / HTTP/1.1
> Host: example.com
> User-Agent: curl/7.47.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Server: nginx/1.10.0 (Ubuntu)
...
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx !</title>
<style>
   body {
...

Hier ist die Ausgabe des zweiten "+ curl +" - Befehls:

Output*   Trying ...
* Connected to  () port 80 (#0)
> GET / HTTP/1.1
> Host: web2.example.com
> User-Agent: curl/7.47.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Server: nginx/1.10.0 (Ubuntu)
...
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx !</title>
<style>
   body {
...

In beiden Fällen wird die richtige Website angezeigt.

Fazit

Sie haben zwei Websites mit HAProxy eingerichtet, die den Datenverkehr leiten. Jede Website befindet sich in einem eigenen Container. Sie können diesen Prozess replizieren, um viele weitere Websites zu konfigurieren, von denen jede auf ihren eigenen Container beschränkt ist.

Sie können auch MySQL in einen neuen Container einfügen und dann ein CMS wie WordPress installieren, um jede Website auszuführen. Sie können diesen Prozess auch zur Unterstützung älterer Softwareversionen verwenden. Wenn für die Installation eines CMS beispielsweise eine ältere Version von PHP5 erforderlich ist, können Sie Ubuntu 14.04 im Container installieren (+ lxc launch ubuntu: t +), anstatt zu versuchen, die unter Ubuntu verfügbaren Versionen des Paketmanagers herunterzustufen 16.04.

Schließlich bietet LXD die Möglichkeit, Snapshots des vollständigen Zustands von Containern zu erstellen. Dies erleichtert das Erstellen von Backups und das Zurücksetzen von Containern zu einem späteren Zeitpunkt. Wenn wir LXD auf zwei verschiedenen Servern installieren, ist es außerdem möglich, diese zu verbinden und Container über das Internet zwischen Servern zu migrieren.

Related