Detaillierte Erläuterung des Nginx-Reverse-Generation-Beispiels für verteilten Mogilefs-Speicher

1. Einführung in verteilte Speichersysteme

Die kontinuierliche Weiterentwicklung der Informationstechnologie bringt uns zwar Komfort, doch die immer größer werdende Datenmenge, die immer komplexeren Verbindungen zwischen Informationen, die zunehmende Gleichzeitigkeit des Datenzugriffs, die immer höheren Anforderungen an die E/A und die immer komplexeren Datentypen sind auch zu Problemen geworden, die dringend gelöst werden müssen, damit sich die Informationstechnologie weiterhin rasant entwickeln kann. Die meisten der oben genannten Probleme wurden durch die Einführung verteilter Speichersysteme weitgehend gelöst.

Ein verteiltes Speichersystem speichert Daten auf mehreren unabhängigen Geräten. Herkömmliche Netzwerkspeichersysteme verwenden zentralisierte Speicherserver zum Speichern aller Daten. Der Speicherserver wird zum Engpass der Systemleistung und zum Schwerpunkt von Zuverlässigkeit und Sicherheit und kann die Anforderungen großer Speicheranwendungen nicht erfüllen. Das verteilte Speichersystem verwendet eine skalierbare Systemstruktur, verwendet mehrere Speicherserver, um die Speicherlast zu teilen, und verwendet Standortserver, um Speicherinformationen zu lokalisieren. Es verbessert nicht nur die Zuverlässigkeit, Verfügbarkeit und Zugriffseffizienz des Systems, sondern lässt sich auch leicht erweitern.

Verteilte Speichersysteme können je nach Schnittstellentyp in allgemein verteilten Speicher und dedizierten verteilten Speicher unterteilt werden. Allgemeiner verteilter Speicher bedeutet, dass keine Dateisystemschnittstelle vorhanden ist und der Zugriff über eine API-Schnittstelle erfolgen muss; dedizierter verteilter Speicher wird auch als verteiltes Dateisystem bezeichnet, das im Allgemeinen über eine Dateisystemschnittstelle verfügt und direkt gemountet werden kann. Zum allgemeinen verteilten Speicher zählen Mogilefs, Fastdfs usw., und zu den speziellen verteilten Speichersystemen zählen Moosefs usw.

2. Mogilefs

MogileFS ist ein Open-Source-System zur verteilten Dateispeicherung. MogileFS eignet sich für Arbeitsszenarien, in denen große kleine Dateien gespeichert werden. Es wurde von Danga Interactive entwickelt, einer Tochtergesellschaft von LiveJournal. Das Team hat viele bekannte Open-Source-Projekte entwickelt, darunter Memcached, MogileFS und Perlbal.

1. Mogilefs-Architekturdiagramm:

2. Bestandteile von Mogliefs:

1.Tracker (mogilefsd): Die Kernkomponente von Mogliefs, deren Hauptfunktionen (Replikation) Knotendateireplikation, (Löschung) Dateilöschung, (Abfrage) Metadatenabfrage, (Monitor) Integritätsüberwachung, (Reaper) Zurücksetzen bei Speicherfehlern usw. sind. Er wird oft als Metadatenserver bezeichnet, speichert jedoch keine Metadaten. Stattdessen werden Metadaten in einer Datenbank wie MySQL gespeichert. Um die Zuverlässigkeit der Architektur zu gewährleisten, gibt es normalerweise mehrere Tracker. Tracker können als Side-by-Side-Proxy betrachtet werden, der nur für die Verarbeitung von Metadateninformationen verantwortlich ist.

2. Datenbank: Die Datenbank wird zum Speichern von Mogliefs-Metadaten verwendet und Tracker verwalten die Daten. Aus diesem Grund wird HA im Allgemeinen empfohlen.

3.mogstored (Speicherknoten): wo die eigentlichen Dateien gespeichert sind. Normalerweise werden mindestens zwei Kopien der eigentlichen Datei gespeichert.

3. Beispiel eines Demonstrationstopologiediagramms

Installieren Sie Tracker und Mogstored gleichzeitig auf drei Knoten und wählen Sie einen der Knoten aus, um MySQL zu installieren. In einer Produktionsumgebung ist es am besten, MySQL separat bereitzustellen und eine Master-Slave-Replikation durchzuführen. Tracker und Mogstored können auch separat auf verschiedenen Knoten bereitgestellt werden. Dies muss basierend auf der tatsächlichen Produktionsumgebung entschieden werden. Dies dient hauptsächlich der Demonstration von Mogilefs und nicht der MySQL-Master-Slave-Replikation. Wenn Sie möchten, dass Mogilefs gemountet werden kann, können Sie dazu FUSE verwenden.

Es ist zu beachten, dass die in mogilefs gespeicherte Datei-URL sehr speziell ist (der Prozess der Generierung von mogilefs-Dateinamen wird später erläutert). Wenn beispielsweise ein Bild gespeichert wird, kann die Datei-URL ein Format ähnlich 6060/0000/0000/0000/00000021.jpg haben, was nicht sehr benutzerfreundlich ist. Benutzer benötigen möglicherweise eine intuitive URL wie image.hello.com/21.jpg. Daher wird Nginx normalerweise als Ersatz für Mogilefs verwendet.

4. Systemumgebung und Installation

Mogilefs ist ein relativ alter, aber ausgereifter verteilter Speicher. Da es unter Centos7 möglicherweise Kompatibilitätsprobleme gibt, wird hier Centos6 zur Demonstration verwendet.

Betriebssystem: CentOS Version 6.6

Mogilefs: 2,46

nginx: 1.10

MySQL: 5.1

IP-Zuweisung:

n1:192.168.29.111, n2:192.168.29.112, n3:192.168.29.113, n4:192.168.29.114

Der Aufbau ist in der Abbildung oben dargestellt.

1. Installieren Sie MySQL, mogilefsd und mogstored auf dem Knoten n1 und konfigurieren Sie n1 als Tracker und Speicherknoten

MySQL wird direkt mit yum installiert.

~]# yum install -y mysql mysql-server

Installieren Sie die Tracker- und Storage Node-Komponenten von Mogilefs. Achten Sie bei der Installation darauf, die Perl-bezogenen Abhängigkeitspakete zu installieren. Diese sind:

perl-Danga-Socket-1.61-1.el6.rf.noarch.rpm
perl-IO-stringy-2.110-1.2.el6.rfx.noarch.rpmperl-Net-Netmask-1.9015-8.el6.noarch.rpm
Perlbal-1.78-1.el6.noarch.rpmperl-Perlbal-1.78-1.el6.noarch.rpm
Perlbal-doc-1.78-1.el6.noarch.rpmperl-IO-AIO-3.71-2.el6.x86_64.rpm

Die oben genannten Abhängigkeitspakete müssen vor der Installation von Mogilefs installiert werden. Installieren Sie die Komponenten:

yum install -y MogileFS-Server-mogstored-2.46-2.el6.noarch.rpm MogileFS-Server-mogilefsd-2.46-2.el6.noarch.rpm MogileFS-Server-2.46-2.el6.noarch.rpm

Konfigurieren Sie MogileFS-Server-mogilefsd:

~]# vim /etc/mogilefs/mogilefsd.conf #Hauptkonfigurationsdatei für Mogilfs Tracker

# Aktivieren Sie den Daemon-Modus, um im Hintergrund zu arbeiten und Syslog zu verwenden
daemonize = 1 #Ob als Daemon-Prozess ausgeführt werden soll.
# Wo soll die PID des Daemons gespeichert werden (muss mit der im Init-Skript identisch sein)
pidfile = /var/run/mogilefsd/mogilefsd.pid #Pfad der PID-Datei# Datenbankverbindungsinformationen
db_dsn = DBI:mysql:mogilefs:host=192.168.29.111 #Datenbankadresse db_user = moguser #Datenbankbenutzernamen und -kennwort konfigurieren db_pass = 123456
# IP:PORT, um auf Anfragen des Mogilefs-Clients zu warten
listen = 0.0.0.0:7001 #Abhöradresse und Port # Optional, wenn Sie den Port oben nicht definieren.
conf_port = 7001 #Standardport # Anzahl der Query-Worker, die standardmäßig gestartet werden sollen.
query_jobs = 10 #Anzahl der Abfrageprozesse # Anzahl der Löschworker, die standardmäßig gestartet werden sollen.
delete_jobs = 1 
# Anzahl der Replikationsworker, die standardmäßig gestartet werden sollen.
replicate_jobs = 5
# Anzahl der Reaper-Worker, die standardmäßig gestartet werden sollen.
# (normalerweise müssen Sie dies nicht erhöhen)
reaper_jobs = 1
# Anzahl der standardmäßig zu startenden Fsck-Worker.
# (diese können beim fsck'ing eine große Belastung verursachen)
#fsck_jobs = 1
# Mindestmenge an zu reservierendem Speicherplatz in Megabyte
# Standard: 100
# Erwägen Sie, diesen Wert größer einzustellen als die größte Datei,
# würde normalerweise hochgeladen werden.
#min_freier_Speicherplatz = 200
# Anzahl der Sekunden, die auf die Antwort eines Speicherknotens gewartet werden soll.
# Standard: 2
# Halten Sie diesen Wert niedrig, damit ausgelastete Speicherknoten schnell ignoriert werden.
#node_timeout = 2
# Anzahl der Sekunden, die auf die Verbindung mit einem Speicherknoten gewartet werden soll.
# Standard: 2
# Halten Sie diesen Wert niedrig, damit überlastete Knoten übersprungen werden.
#conn_timeout = 2
# Erlauben Sie der Replikation, den Get-Port des sekundären Knotens zu verwenden.
# wenn Sie Apache oder ähnliches für GET konfiguriert haben
#repl_use_get_port = 1

Rufen Sie nach der Änderung der Konfiguration die Datenbank auf, um einen Root-Benutzer zu erstellen, der eine Remoteverbindung herstellen kann, oder verwenden Sie mogdbsetup, um die Datenbank zu initialisieren:

mysql> GRANT ALL ON mogilefs.* TO 'moguser'@'192.168.29.%' IDENTIFIED BY '123456'; #Erstellen Sie den Benutzer moguser, der über alle Berechtigungen zum Verwalten der mogilefs-Datenbank verfügt und Benutzern unter 192.168.29.* eine Remoteverbindung ermöglicht.
mysql> FLUSH-PRIVILEGIEN;
mysql> beenden

~]# mogdbsetup --dbhost=127.0.0.1 --dbuser=moguser --dbpass=123456

Nach Abschluss der Initialisierung können Sie die erstellte mogilefs-Bibliothek und die darin enthaltenen Tabellen in MySQL sehen:

Starten Sie mogilefs und bestätigen Sie, dass Port 7001 im Listening-Status ist:

~]# Dienst mogilefsd starten
mogilefsd wird gestartet [ OK ]
~]# ss -lnt

Hinweis: Sie können Tracker-Dienste sowohl auf N2- als auch auf N3-Knoten installieren, um das Risiko eines einzelnen Punktausfalls und eines durchschnittlichen E/A-Drucks zu eliminieren.

3. Konfigurieren Sie den Speicherknoten auf n1

Der Pfad der Storage Node-Konfigurationsdatei lautet /etc/mogilefs/mogstored.conf:

~]# vim /etc/mogilefs/mogstored.conf
maxconns = 10000 #Maximale Anzahl gleichzeitiger Verbindungenhttplisten = 0.0.0.0:7500 #Die Datenübertragung von Mogilefs erfolgt über das http-Protokoll. Hier sind die Abhöradresse und der Portmgmtlisten = 0.0.0.0:7501 #Abhöradresse und Port für die Gesundheitsüberwachungdocroot = /mogliefs/mogdata #Datenspeicherpfad. Die Gruppe und der Eigentümer des Verzeichnisses müssen mogilefs sein

Erstellen Sie ein Datenspeicherverzeichnis und ändern Sie die Gruppe und den Eigentümer in mogilefs:

~]# mkdir -pv /mogliefs/mogdata
~]# chown -R mogilefs.mogilefs /mogliefs/

Starten Sie mogstored und prüfen Sie, ob der Prozess normal gestartet wird und ob der Port lauscht:

~]# Dienst Mogstored Start
~]# ss -lnt #Die Abhörports sind 7500 und 7501

4. Befolgen Sie die Schritte von n1, um Mogilefs auf den Knoten n2 und n3 zu installieren, und kopieren Sie die Konfigurationsdatei von n1 nach n2 und n3.

~]# scp /etc/mogilefs/*.conf [email protected]:/etc/mogilefs/
~]# scp /etc/mogilefs/*.conf [email protected]:/etc/mogilefs/

Starten Sie den mogstored-Dienst und bestätigen Sie die Überwachung:

~]# Dienst Mogstored Start
~]# ss -lnt #Die Abhörports sind 7500 und 7501

5. Verwenden Sie den Befehl mogadm auf n1, um alle Knoten in einen Cluster zu integrieren.

Fügen Sie einen Speicherknoten hinzu und überprüfen Sie:

1 ~]# mogadm host add 192.168.29.111 --ip=192.168.29.111 --port=7500 --status=alive
2 ~]# mogadm host add 192.168.29.112 --ip=192.168.29.112 --port=7500 --status=alive
3 ~]# mogadm host add 192.168.29.113 --ip=192.168.29.113 --port=7500 --status=alive

~]# Mogadm-Prüfung

Wenn der Speicher im Mogilefs-Cluster als unterschiedliche Geräte erkannt werden soll, müssen Sie unter dem erstellten Verzeichnis /mogliefs/mogdata ein Verzeichnis mit dem Namen dev* erstellen, damit jeder Knoten als Speichergerät verwendet werden kann. Mogilefs speichert Redundanz in verschiedenen Geräten und jeder Knoten sollte als anderes Gerät identifiziert werden.

Erstellen Sie die Verzeichnisse dev1, dev2 und dev3 im Verzeichnis /mogliefs/mogdata/ auf n1, n2 und n3 und fügen Sie Geräte zu Trackern hinzu:

1 ~]# mogadm-Gerät hinzufügen 192.168.29.111 1
2 ~]# mogadm-Gerät hinzufügen 192.168.29.112 2
3 ~]# mogadm-Gerät hinzufügen 192.168.29.113 3

6. Domäne und Klasse erstellen

Um die Verwaltung von Dateikopien auf mehreren Knoten zu erleichtern, werden Dateien in Mogilefs normalerweise nicht als Einheiten im Gerät, sondern als Klassen verwaltet. Vorgänge wie Kopieren und Löschen werden mit der Klasse als kleinster Einheit ausgeführt. In jeder Klasse können viele Dateien abgelegt werden und die Größe der Klasse ist nicht festgelegt.

Im Speicherplatz von Mogilefs befinden sich alle Datendateien auf derselben Ebene. Daher kann es nicht vorkommen, dass Dateien denselben Namen haben, da dies die Flexibilität von Mogilefs beeinträchtigen würde. Daher wird das Konzept der Domäne (Namespace) eingeführt. Die Domäne enthält die Klasse und der gleiche Dateiname kann in verschiedenen Domänen vorhanden sein.

~]# mogadm domain add imgs #Erstellen Sie eine Domäne mit dem Namen imgs
~]# mogadm domain add text #Erstellen Sie eine Domäne mit dem Namen text
~]# mogadm domain list #Domänenliste anzeigen

Sie können die Eigenschaften der Klasse anpassen. Das Format ist: mogadm class add <domain> <class> [opts]

~]# mogadm class add imgs png --mindevcount=3 --hashtype=MD5 #Definieren Sie eine Klasse namens png in Domain imgs, kopieren Sie 3 Kopien auf verschiedene Geräte und verwenden Sie MD5 zur Überprüfung~]# mogadm class add imgs jpg --mindevcount=3 --hashtype=MD5 #Definieren Sie eine Klasse namens jpg in Domain imgs, kopieren Sie 3 Kopien auf verschiedene Geräte und verwenden Sie MD5 zur Überprüfung~]# mogadm domain list

7. Verwenden Sie Mogilefs, um Upload- und Download-Tests durchzuführen

Mogilefs kann mit einer eigenen API-Schnittstelle interagieren, die viele Befehle zur Verwaltung gespeicherter Daten enthält. Beispielsweise lautet der Befehl zum Hochladen von Daten „mogupload“, der Befehl zum Anzeigen von Daten „mogfileinfo“ usw.

Beispiel: Testen Sie das Hochladen der Datei /test/123.png in den Mogilefs-Cluster (die Datei wird vorab lokal vorbereitet):

~]# mogupload --trackers=192.168.29.111 --domain=imgs --class=png --key='/111.png' --file='/test/123.png' #Laden Sie die Datei 123.png über Tracker mit der IP 192.168.29.111 hoch, speichern Sie sie im Bereich mit der Domäne „imgs“ und der Klasse „png“ und benennen Sie sie in 111.png um
~]# mogfileinfo --trackers=192.168.29.111 --domain=imgs --class=png --key='/111.png' #Überprüfen Sie den Speicherstatus von Dateien mit Schlüssel 111.png in der Domäne „imgs“ und der Klasse „png“. 

An diesem Punkt wurde der verteilte Speichercluster Mogilefs erstellt. Wenn Sie jedoch möchten, dass der Client mit ihm kommuniziert, müssen Sie die Schnittstelle programmieren, was sehr mühsam ist. Glücklicherweise können wir Nginx als Reverse-Proxy für die Kommunikation verwenden. Im Folgenden werden die Schritte zum Reverse Mogilefs von Nginx demonstriert.

5. Nginx Anti-Generation Mogilefs

1. Öffnen Sie den mogilefsd-Dienst von n2 und n3 und legen Sie alle drei Knoten als Tracker fest (stellen Sie sicher, dass die Konfigurationsdatei mit der von n1 identisch ist):

~]# Dienst mogilefsd starten

2. Kompilieren und installieren Sie Nginx auf dem Knoten n4

Installieren Sie Abhängigkeitspakete:

~]# yum installiere gcc gcc-c++ perl pcre-devel openssl openssl-devel

Laden Sie das Nginx-Kompilierungsinstallationspaket nginx-1.10.3.tar.gz und das Nginx_Mogilefs-Modul nginx_mogilefs_module-1.0.4.tar.gz herunter und entpacken Sie sie:

~]# ls
nginx-1.10.3 nginx_mogilefs_module-1.0.4
nginx-1.10.3.tar.gz nginx_mogilefs_module-1.0.4.tar.gz

~]# cd nginx-1.10.3
./konfigurieren \
> --prefix=/usr \
> --sbin-path=/usr/sbin/nginx \
> --conf-path=/etc/nginx/nginx.conf \
> --error-log-path=/var/log/nginx/error.log \
> --http-log-path=/var/log/nginx/access.log \
> --pid-path=/var/run/nginx/nginx.pid \
> --lock-path=/var/lock/nginx.lock \
> --user=nginx \
> --group=nginx \
> --mit-http_ssl_module \
> --mit-http_flv_module \
> --mit-http_stub_status_module \
> --mit-http_gzip_static_module \
> --http-client-body-temp-path=/var/tmp/nginx/client/ \
> --http-proxy-temp-path=/var/tmp/nginx/proxy/ \
> --http-fastcgi-temp-path=/var/tmp/nginx/fcgi/ \
> --http-uwsgi-temp-path=/var/tmp/nginx/uwsgi \
> --http-scgi-temp-path=/var/tmp/nginx/scgi \
> --mit-pcre \
> --mit-debug \
> --add-module=../nginx_mogilefs_module-1.0.4/ #Fügen Sie unbedingt den Pfad hinzu, in dem sich das Mogilefs-Modul befindet. Das ist wichtig.

~]# machen und machen installieren

Fügen Sie den Nginx-Benutzer hinzu und starten Sie Nginx:

~]# useradd -s /sbin/nologin -M nginx
~]# /usr/sbin/nginx

3. Nginx konfigurieren

Beispiel für einen einzelnen Tracker:

Standort /imgs/ {
   mogilefs_tracker 192.168.29.111:7001; #Beispiel für einzelne Tracker mogilefs_domain imgs; #Domäne angeben
   mogilefs_class png jpg; #Klasse angeben

   mogilefs_pass { #übertragungsbezogene Konfiguration proxy_pass $mogilefs_path;
    proxy_hide_header Inhaltstyp;
    Proxy-Pufferung aus;
   }
  }

Beispiel für mehrere Tracker:

Fügen Sie das Planungsmodul zum Abschnitt „HTTP-Konfiguration“ in der Nginx-Konfiguration hinzu:

1 Upstream-Mogsvr {
2 Server 192.168.29.111:7001;
3 Server 192.168.29.112:7001;
4 Server 192.168.29.113:7001;
5 }

Fügen Sie dem Abschnitt „Serverkonfiguration“ in der Nginx-Konfiguration Folgendes hinzu:

Standort /imgs/ {
    mogilefs_tracker mogsvr;
   mogilefs_domain-Bilder;
   mogilefs_klasse png jpg;

   mogilefs_pass {
    Proxy-Passwort $mogilefs_Pfad;
    proxy_hide_header Inhaltstyp;
    Proxy-Pufferung aus;
   }
  }

Starten Sie nginx neu und greifen Sie über nginx auf die zuvor hochgeladenen Bilder zu:

Zusammenfassen:

Beim Hochladen von Dateien wurde die Fehlermeldung MogileFS::Backend: Verbindung zu mogilefsdbackend unter /usr/local/share/perl/5.8.4/Client.pm Zeile 282 nicht hergestellt. Dies liegt daran, dass der mogilefsd-Dienst keine Verbindung zu MySQL herstellen kann. Sie können den Fehler finden, indem Sie die Verbindung zwischen ihnen überprüfen.

Nun, das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Lernwert für Ihr Studium oder Ihre Arbeit hat. Wenn Sie Fragen haben, können Sie eine Nachricht hinterlassen. Vielen Dank für Ihre Unterstützung von 123WORDPRESS.COM.