Erstellen Sie Schritt für Schritt ein Dateiverwaltungssystem mit nginx+FastDFS

1. Einführung in FastDFS

FastDFS Open-Source-Adresse: https://github.com/happyfish100

Referenz: Designprinzipien des verteilten Dateisystems FastDFS

Referenz: Verteiltes Dateisystem FastDFS

Persönlich gepackte FastDFS Java API: https://github.com/bojiangzhou/lyyzoo-fastdfs-java

1. Einleitung

FastDFS ist ein Open-Source-Hochleistungs-Verteiltes Dateisystem (DFS). Zu seinen Hauptfunktionen gehören: Dateispeicherung, Dateisynchronisierung und Dateizugriff sowie hohe Kapazität und Lastausgleich. Es löst hauptsächlich das Problem der Massendatenspeicherung und eignet sich besonders für Online-Dienste, die kleine und mittelgroße Dateien (empfohlener Bereich: 4 KB < Dateigröße < 500 MB) als Träger verwenden.

Das FastDFS-System hat drei Rollen: Tracker-Server, Storage-Server und Client.

Tracker-Server : Tracking-Server, der hauptsächlich für die Planung und den Ausgleich verantwortlich ist; verantwortlich für die Verwaltung aller Speicherserver und -gruppen. Nach dem Start stellt jeder Speicher eine Verbindung zum Tracker her, informiert ihn über Informationen wie die Gruppe, zu der er gehört, und verwaltet regelmäßige Heartbeats.

Speicherserver: Speicherserver stellen hauptsächlich Kapazitäts- und Sicherungsdienste bereit. Sie sind in Gruppen organisiert und jede Gruppe kann mehrere Speicherserver haben, deren Daten sich gegenseitig sichern.

Client : Der Client ist der Server, der Daten hoch- und herunterlädt, und auch der Server, auf dem unser eigenes Projekt bereitgestellt wird.

2. FastDFS-Speicherstrategie

Um große Kapazitäten zu unterstützen, werden Speicherknoten (Server) in Volumes (oder Gruppen) organisiert. Das Speichersystem besteht aus einem oder mehreren Volumes. Die Dateien zwischen den Volumes sind voneinander unabhängig. Die Summe der Dateikapazitäten aller Volumes ergibt die Dateikapazität des gesamten Speichersystems. Ein Volume kann aus einem oder mehreren Speicherservern bestehen. Die Dateien auf den Speicherservern unter einem Volume sind identisch. Mehrere Speicherserver im Volume übernehmen die Rolle der redundanten Sicherung und des Lastausgleichs.

Wenn Sie einem Volume einen Server hinzufügen, synchronisiert das System automatisch vorhandene Dateien. Nach Abschluss der Synchronisierung schaltet das System den neu hinzugefügten Server automatisch online, um Dienste bereitzustellen. Wenn der Speicherplatz knapp wird oder zur Neige geht, können Volumes dynamisch hinzugefügt werden. Fügen Sie einfach einen oder mehrere Server hinzu und konfigurieren Sie sie als neues Volume, um die Kapazität des Speichersystems zu erweitern.

3. FastDFS-Upload-Prozess

FastDFS bietet Benutzern grundlegende Dateizugriffsschnittstellen wie Hochladen, Herunterladen, Anhängen, Löschen usw. in Form einer Client-Bibliothek.

Der Speicherserver sendet seine Speicherinformationen regelmäßig an den Tracker-Server. Wenn sich im Tracker-Server-Cluster mehr als ein Tracker-Server befindet, ist die Beziehung zwischen den einzelnen Trackern gleich, sodass der Client beim Hochladen einen beliebigen Tracker auswählen kann.

Wenn Tracker von einem Client eine Anfrage zum Hochladen einer Datei erhält, weist er der Datei eine Gruppe zu, die die Datei speichern kann. Nachdem die Gruppe ausgewählt wurde, wird entschieden, welcher Speicherserver in der Gruppe dem Client zugewiesen wird. Nachdem der Speicherserver zugewiesen wurde, sendet der Client eine Dateischreibanforderung an den Speicher und der Speicher weist der Datei ein Datenspeicherverzeichnis zu. Weisen Sie der Datei dann eine Datei-ID zu und generieren Sie schließlich basierend auf den obigen Informationen einen Dateinamen zum Speichern der Datei.

4. Dateisynchronisierung von FastDFS

Beim Schreiben einer Datei betrachtet der Client das Schreiben der Datei als erfolgreich, wenn er die Datei auf einen Speicherserver in der Gruppe schreibt. Nachdem der Speicherserver das Schreiben der Datei abgeschlossen hat, synchronisiert der Hintergrundthread die Datei mit anderen Speicherservern in derselben Gruppe.

Nachdem jeder Speicher eine Datei geschrieben hat, wird auch ein Binärprotokoll geschrieben. Das Binärprotokoll enthält keine Dateidaten, sondern nur Metadaten wie den Dateinamen. Dieses Binärprotokoll wird für die Hintergrundsynchronisierung verwendet. Der Speicher zeichnet den Fortschritt der Synchronisierung mit anderen Speichern in der Gruppe auf, sodass die Synchronisierung nach einem Neustart fortgesetzt werden kann. Der Fortschritt wird in Form von Zeitstempeln aufgezeichnet. Daher ist es am besten, sicherzustellen, dass die Uhren aller Server im Cluster synchronisiert sind.

Der Synchronisierungsfortschritt des Speichers wird dem Tracker als Teil der Metadaten gemeldet. Der Tracker verwendet den Synchronisierungsfortschritt als Referenz, wenn er sich für das Lesen des Speichers entscheidet.

5. Dateidownload mit FastDFS

Nachdem der Client die Datei erfolgreich hochgeladen hat, erhält er einen vom Speicher generierten Dateinamen. Anschließend kann der Client anhand dieses Dateinamens auf die Datei zugreifen.

Genau wie beim Hochladen von Dateien kann der Client beim Herunterladen von Dateien einen beliebigen Tracker-Server auswählen. Wenn ein Tracker eine Download-Anforderung an einen Tracker sendet, muss diese die Dateinameninformationen enthalten. Der Tracker analysiert die Dateigruppe, Größe, Erstellungszeit und andere Informationen aus dem Dateinamen und wählt dann einen Speicher für die Anforderung aus, um die Leseanforderung zu erfüllen.

2. Installieren Sie die FastDFS-Umgebung

0. Einleitung

Betriebsumgebung: CentOS7 X64, die folgenden Vorgänge sind alle eigenständige Umgebungen.

Ich habe alle Installationspakete nach /softpackages/ heruntergeladen und in das aktuelle Verzeichnis entpackt.

Als Erstes müssen Sie die Hosts ändern und die IP-Adresse des Dateiservers dem Domänennamen zuordnen (eigenständige TrackerServer-Umgebung). Dies liegt daran, dass Sie die Serveradresse in vielen nachfolgenden Konfigurationen neu konfigurieren müssen. Wenn sich die IP-Adresse ändert, müssen Sie nur die Hosts ändern.

# vim /etc/hosts

Fügen Sie die folgende Zeile hinzu: Dies ist meine IP
192.168.51.128 Datei.ljzsg.com

Wenn Sie lokal auf die virtuelle Maschine zugreifen möchten, fügen Sie eine Zeile in C:\Windows\System32\drivers\etc\hosts hinzu

1. Laden Sie libfastcommon herunter und installieren Sie es

libfastcommon ist eine allgemeine C-Funktionsbibliothek, die aus FastDFS und FastDHT, einer Basisumgebung, extrahiert wird und installiert werden kann.

① Laden Sie libfastcommon herunter

# wget https://github.com/happyfish100/libfastcommon/archive/V1.0.7.tar.gz

② Dekompression

# tar -zxvf V1.0.7.tar.gz
# cd libfastcommon-1.0.7

③ Kompilieren und installieren

# ./make.sh#
./make.sh installieren

④ libfastcommon.so wird in /usr/lib64/libfastcommon.so installiert, aber das vom FastDFS-Hauptprogramm festgelegte Lib-Verzeichnis ist /usr/local/lib, daher muss ein Softlink erstellt werden.

# ln -s /usr/lib64/libfastcommon.so /usr/local/lib/libfastcommon.so
# ln -s /usr/lib64/libfastcommon.so /usr/lib/libfastcommon.so
# ln -s /usr/lib64/libfdfsclient.so /usr/local/lib/libfdfsclient.so
# ln -s /usr/lib64/libfdfsclient.so /usr/lib/libfdfsclient.so

2. Laden Sie FastDFS herunter und installieren Sie es

① Laden Sie FastDFS herunter

# wget https://github.com/happyfish100/fastdfs/archive/V5.05.tar.gz

② Dekompression

# tar -zxvf V5.05.tar.gz
# cd fastdfs-5.05

③ Kompilieren und installieren

# ./make.sh
# ./make.sh installieren

④ Entsprechende Dateien und Verzeichnisse nach der Standardinstallation

A. Serviceskript:

/etc/init.d/fdfs_storaged
/etc/init.d/fdfs_tracker

B. Konfigurationsdateien (diese drei sind vom Autor bereitgestellte Beispielkonfigurationsdateien):

/etc/fdfs/client.conf.sample
/etc/fdfs/storage.conf.sample
/etc/fdfs/tracker.conf.sample

C. Das Befehlstool befindet sich im Verzeichnis /usr/bin/:

fdfs_appender_test
fdfs_appender_test1
fdfs_append_file
fdfs_crc32
fdfs_datei_löschen
fdfs_downloaddatei
fdfs_datei_info
fdfs_monitor
fdfs_gespeichert
fdfs_test
fdfs_test1
fdfs_trackerd
fdfs_upload_appender
fdfs_upload_datei
stopp.sh
Neustart.sh

⑤ Das vom FastDFS-Dienstskript festgelegte Bin-Verzeichnis ist /usr/local/bin, aber die eigentlichen Befehle werden unter /usr/bin/ installiert.

Zwei Möglichkeiten:

》 Ändern Sie zunächst den entsprechenden Befehlspfad im FastDFS-Dienstskript, d. h. ändern Sie /usr/local/bin in den beiden Skripten /etc/init.d/fdfs_storaged und /etc/init.d/fdfs_tracker in /usr/bin.

# vim fdfs_trackerd
Verwenden Sie den Suchen- und Ersetzen-Befehl, um einheitliche Änderungen vorzunehmen: %s+/usr/local/bin+/usr/bin
# vim fdfs_storaged
Verwenden Sie den Suchen- und Ersetzen-Befehl, um einheitliche Änderungen vorzunehmen: %s+/usr/local/bin+/usr/bin

》 Die zweite Möglichkeit besteht darin, einen Softlink von /usr/bin nach /usr/local/bin zu erstellen. Ich verwende diese Methode.

# ln -s /usr/bin/fdfs_trackerd /usr/local/bin
# ln -s /usr/bin/fdfs_storaged /usr/local/bin
# ln -s /usr/bin/stop.sh /usr/local/bin
# ln -s /usr/bin/restart.sh /usr/local/bin

3. FastDFS Tracker konfigurieren

Eine detaillierte Beschreibung der Konfigurationsdatei finden Sie unter: Detaillierte Beschreibung der FastDFS-Konfigurationsdatei

① Gehen Sie zu /etc/fdfs, kopieren Sie die Beispielkonfigurationsdatei des FastDFS-Trackers tracker.conf.sample und benennen Sie sie in tracker.conf um.

# cd /etc/fdfs
# cp tracker.conf.sample tracker.conf
# vim tracker.conf

② Bearbeiten Sie tracker.conf. Die rot markierten Dateien müssen geändert werden, die anderen können als Standard belassen werden.

# Ob die Konfigurationsdatei unwirksam ist, false bedeutet, dass sie wirksam ist disabled=false
# Der Port, der den Dienst bereitstellt, ist Port=22122
# Tracker-Daten und Log-Verzeichnisadresse (das Stammverzeichnis muss vorhanden sein, Unterverzeichnisse werden automatisch erstellt)
Basispfad = /ljzsg/fastdfs/tracker
# HTTP-Dienstport http.server_port=80

③ Erstellen Sie das Tracker-Basisdatenverzeichnis, dh das Verzeichnis, das dem Basispfad entspricht

# mkdir -p /ljzsg/fastdfs/tracker

④ Öffnen Sie den Tracking-Port in der Firewall (Standard 22122).

# vim /etc/sysconfig/iptables
Fügen Sie die folgende Portzeile hinzu:
-A INPUT -m Status --state NEU -m tcp -p tcp --dport 22122 -j AKZEPTIEREN
Starten Sie die Firewall neu:
# Dienst iptables neu starten

⑤ Tracker starten

Beim ersten erfolgreichen Start werden zwei Verzeichnisse, „data“ und „logs“, unter /ljzsg/fdfsdfs/tracker/ (konfigurierter Basispfad) erstellt.

So können Sie es starten
# /etc/init.d/fdfs_trackerd starten
Sie können es auch auf diese Weise starten, sofern oben ein Softlink erstellt wurde und diese Methode später verwendet wird
# Dienst fdfs_trackerd starten

Überprüfen Sie, ob FastDFS Tracker erfolgreich gestartet wurde und Port 22122 abgehört wird. Dies bedeutet, dass der Tracker-Dienst erfolgreich installiert wurde.

# netstat -unltp|grep fdfs

Befehl „Tracker deaktivieren“:

# Dienst fdfs_trackerd stoppen

⑥ Stellen Sie den Tracker so ein, dass er beim Booten gestartet wird

# chkconfig fdfs_trackerd ein

oder:
# vim /etc/rc.d/rc.local
Konfiguration hinzufügen:
/etc/init.d/fdfs_trackerd starten

⑦ Tracker-Serververzeichnis und Dateistruktur

Nachdem der Tracker-Dienst erfolgreich gestartet wurde, werden unter base_path zwei Verzeichnisse, data und logs, erstellt. Die Verzeichnisstruktur ist wie folgt:

${Basispfad}
 |__Daten
 | |__storage_groups.dat: Speichergruppeninformationen| |__storage_servers.dat: Speicherserverliste|__logs
 | |__trackerd.log: Tracker-Server-Protokolldatei

4. FastDFS-Speicher konfigurieren

① Geben Sie das Verzeichnis /etc/fdfs ein, kopieren Sie die FastDFS-Speicherbeispielkonfigurationsdatei storage.conf.sample und benennen Sie sie in storage.conf um

# cd /etc/fdfs
# cp speicher.conf.sample speicher.conf
# vim storage.conf

② Bearbeiten Sie storage.conf

Die rot markierten müssen geändert werden, die anderen können als Standard belassen werden.

# Ob die Konfigurationsdatei unwirksam ist, false bedeutet, dass sie wirksam ist disabled=false 

#Geben Sie die Gruppe (Volume) an, in der sich dieser Speicherserver befindet
Gruppenname=Gruppe1

# Speicherserver-Dienstport Port=23000

# Heartbeat-Intervall in Sekunden (bezieht sich auf das aktive Senden von Heartbeats an den Tracker-Server)
Herzschlagintervall = 30

# Speicherdaten- und Protokollverzeichnisadresse (das Stammverzeichnis muss vorhanden sein, Unterverzeichnisse werden automatisch generiert)
Basispfad=/ljzsg/fastdfs/storage

# Der Speicherserver unterstützt mehrere Pfade beim Speichern von Dateien. Hier wird die Anzahl der Basispfade zur Dateiablage konfiguriert, üblicherweise wird nur ein Verzeichnis konfiguriert.
Anzahl der Store-Pfade = 1


# Konfigurieren Sie store_path_count-Pfade einzeln, mit Indexnummern basierend auf 0.
# Wenn store_path0 nicht konfiguriert ist, ist es derselbe Pfad wie der entsprechende base_path.
store_path0=/ljzsg/fastdfs/Datei

# FastDFS verwendet zum Speichern von Dateien zweistufige Verzeichnisse. Hier wird die Anzahl der Verzeichnisse konfiguriert, in denen Dateien gespeichert werden. 
# Wenn dieser Parameter nur N ist (z. B. 256), erstellt der Speicherserver beim ersten Ausführen automatisch N * N Unterverzeichnisse zum Speichern von Dateien unter store_path.
Unterverzeichnisanzahl pro Pfad = 256

# Liste der Tracker-Server, die sich aktiv mit dem Tracker-Server verbinden
# Wenn mehrere Tracker-Server vorhanden sind, schreiben Sie für jeden Tracker-Server eine Zeile: tracker_server=file.ljzsg.com:22122# Der für die Systemsynchronisierung zulässige Zeitraum (der Standardwert ist der ganze Tag). Dies wird normalerweise eingestellt, um Probleme durch Spitzensynchronisierung zu vermeiden. Synchronisierungsstartzeit = 00:00 Synchronisierungsendzeit = 23:59
# Zugriffsport http.server_port=80

③ Erstellen Sie ein Storage-Basisdatenverzeichnis, das dem base_path-Verzeichnis entspricht

# mkdir -p /ljzsg/fastdfs/storage

# Dies ist der konfigurierte store_path0-Pfad
# mkdir -p /ljzsg/fastdfs/Datei

④ Öffnen Sie den Speicherport in der Firewall (Standard 23000)

# vim /etc/sysconfig/iptables

Fügen Sie die folgende Portzeile hinzu:
-A INPUT -m Status --state NEU -m tcp -p tcp --dport 23000 -j AKZEPTIEREN

Starten Sie die Firewall neu:
# Dienst iptables neu starten

⑤ Speicher starten

Stellen Sie sicher, dass Tracker aktiviert ist, bevor Sie Speicher aktivieren. Wenn der erste Start erfolgreich ist, werden unter dem Verzeichnis /ljzsg/fastdfs/storage zwei Verzeichnisse, „data“ und „logs“, erstellt.

So können Sie es starten
# /etc/init.d/fdfs_storaged starten

Sie können diese Methode auch verwenden und später erneut verwenden.
# Dienst fdfs_storaged starten

Überprüfen Sie, ob Storage erfolgreich gestartet wurde. Port 23000 wird überwacht, was bedeutet, dass Storage erfolgreich gestartet wurde.

# netstat -unltp|grep fdfs

So deaktivieren Sie den Speicherbefehl:

# Dienst fdfs_storaged stoppen

Überprüfen Sie, ob Storage und Tracker kommunizieren:

/usr/bin/fdfs_monitor /etc/fdfs/storage.conf

⑥ Speicher so einstellen, dass er beim Booten startet

# chkconfig fdfs_storaged ein

oder:
# vim /etc/rc.d/rc.local
Konfiguration hinzufügen:
/etc/init.d/fdfs_storaged starten

⑦ Speicherverzeichnis

Ähnlich wie bei Tracker werden nach dem erfolgreichen Start von Storage Daten- und Protokollverzeichnisse unter base_path erstellt, um die Informationen des Storage-Servers aufzuzeichnen.

Unter dem Verzeichnis store_path0 werden N*N Unterverzeichnisse erstellt:

5. Datei-Upload-Test

① Ändern Sie die Client-Konfigurationsdatei im Tracker-Server

# cd /etc/fdfs
# cp client.conf.sample client.conf
# vim client.conf

Ändern Sie einfach die folgende Konfiguration und belassen Sie die anderen als Standard.

# Clientdaten- und Protokollverzeichnis
Basispfad=/ljzsg/fastdfs/client

# Tracker-Port
tracker_server=file.ljzsg.com:22122

② Upload-Test

Führen Sie den folgenden Befehl in Linux aus, um das Bild namei.jpeg hochzuladen

# /usr/bin/fdfs_upload_file /etc/fdfs/client.conf namei.jpeg

Nach erfolgreichem Upload wird die Datei-ID-Nummer zurückgegeben: group1/M00/00/00/wKgz6lnduTeAMdrcAAEoRmXZPp870.jpeg

Die zurückgegebene Datei-ID besteht aus der Gruppe, dem Speicherverzeichnis, den zweistufigen Unterverzeichnissen, der Datei-ID und dem Dateisuffix (vom Client angegeben, hauptsächlich zur Unterscheidung von Dateitypen verwendet).

3. Installieren Sie Nginx

Die Datei wurde oben erfolgreich hochgeladen, wir konnten sie jedoch nicht herunterladen. Daher wird Nginx als Server installiert, um den HTTP-Zugriff auf Dateien zu unterstützen. Gleichzeitig ist die Nginx-Umgebung auch erforderlich, um das Nginx-Modul von FastDFS später zu installieren.

Um auf Dateien zugreifen zu können, muss Nginx nur auf dem Server installiert werden, auf dem sich der StorageServer befindet. Da es sich hier um eine einzelne Maschine handelt, liegen TrackerServer und StorageServer auf dem gleichen Server.

1. Installieren Sie die für nginx erforderliche Umgebung

① GCC-Installation

# yum installiere gcc-c++

② PCRE pcre-devel-Installation

# yum install -y pcre pcre-devel

③ zlib-Installation

# yum install -y zlib zlib-devel

④ OpenSSL-Installation

# yum install -y openssl openssl-devel

2. Installieren Sie Nginx

① Laden Sie nginx herunter

# wget -c https://nginx.org/download/nginx-1.12.1.tar.gz

② Dekompression

# tar -zxvf nginx-1.12.1.tar.gz
# cd nginx-1.12.1

③ Standardkonfiguration verwenden

# ./konfigurieren

④ Kompilieren und installieren

# machen
# make installieren

⑤ Starten Sie nginx

# cd /usr/local/nginx/sbin/
# ./nginx

Andere Befehle
# ./nginx -s stoppen
# ./nginx -s beenden
# ./nginx -s neu laden

⑥ Start einrichten

# vim /etc/rc.local

Fügen Sie eine Zeile hinzu:
/usr/local/nginx/sbin/nginx

# Ausführungsberechtigungen festlegen
# chmod 755 rc.local

⑦ Überprüfen Sie die Version und das Modul von nginx

/usr/local/nginx/sbin/nginx -V

⑧ Öffnen Sie den Nginx-Port in der Firewall (Standard 80).

Nach dem Hinzufügen können Sie über Port 80 auf diesem Computer darauf zugreifen.

# vim /etc/sysconfig/iptables

Fügen Sie die folgende Portzeile hinzu:
-A INPUT -m Status --state NEU -m tcp -p tcp --dport 80 -j AKZEPTIEREN

Starten Sie die Firewall neu:
# Dienst iptables neu starten 

3. Auf Dateien zugreifen

Einfache Testzugangsdatei

① Ändern Sie nginx.conf

# vim /usr/local/nginx/conf/nginx.conf

Fügen Sie die folgende Zeile hinzu, um /group1/M00 /ljzsg/fastdfs/file/data zuzuordnen
Standort /Gruppe1/M00 {
 Alias ​​/ljzsg/fastdfs/Datei/Daten;
}# Starten Sie nginx neu# /usr/local/nginx/sbin/nginx -s reload

② Greifen Sie erfolgreich im Browser auf das zuvor hochgeladene Bild zu.

http://file.ljzsg.com/group1/M00/00/00/wKgz6lnduTeAMdrcAAEoRmXZPp870.jpeg

4. FastDFS-Konfiguration Nginx-Modul

1. Installieren und konfigurieren Sie das Nginx-Modul

① Beschreibung des Fastdfs-Nginx-Modulmoduls

FastDFS speichert Dateien über den Tracker-Server auf dem Speicherserver, aber Dateien müssen zwischen den Speicherservern in derselben Gruppe kopiert werden, was zu Synchronisierungsverzögerungen führt.

Angenommen, der Tracker-Server lädt die Datei auf 192.168.51.128 hoch und die Datei-ID wird nach erfolgreichem Upload an den Client zurückgegeben.

Zu diesem Zeitpunkt synchronisiert der FastDFS-Speicherclustermechanismus diese Datei mit dem Speicher in derselben Gruppe 192.168.51.129. Wenn der Client diese Datei-ID verwendet, um die Datei unter 192.168.51.129 abzurufen, bevor die Datei kopiert wird, wird eine Fehlermeldung angezeigt, die angibt, dass auf die Datei nicht zugegriffen werden kann.

Das Fastdfs-Nginx-Modul kann Dateilinks zum Quellserver umleiten, um Dateien abzurufen. Dadurch werden Dateizugriffsfehler vermieden, die durch Verzögerungen bei der Clientreplikation verursacht werden.

② Laden Sie das Fastdfs-Nginx-Modul herunter und entpacken Sie es

# Warum gibt es hier so eine lange Zeichenfolge? Weil es einige Versionsprobleme zwischen der neuesten Version von Master und dem aktuellen Nginx gibt.
# wget https://github.com/happyfish100/fastdfs-nginx-module/archive/5e5f3566bbfa57418b5506aaefbe107a42c9fcb1.zip

# entpacken Sie 5e5f3566bbfa57418b5506aaefbe107a42c9fcb1.zip

# Umbenennen # mv fastdfs-nginx-module-5e5f3566bbfa57418b5506aaefbe107a42c9fcb1 fastdfs-nginx-module-master

③ Nginx konfigurieren

Hinzufügen von Modulen zu nginx

# Stoppen Sie zuerst den nginx-Dienst# /usr/local/nginx/sbin/nginx -s stop Wechseln Sie in das dekomprimierte Paketverzeichnis# cd /softpackages/nginx-1.12.1/

# Modul hinzufügen# ./configure --add-module=../fastdfs-nginx-module-master/src

Neu kompilieren und installieren # make && make install

④ Nginx-Module anzeigen

# /usr/local/nginx/sbin/nginx -V

Das Folgende zeigt an, dass das Modul erfolgreich hinzugefügt wurde

⑤ Kopieren Sie die Konfigurationsdatei im Quellcode des Fastdfs-Nginx-Moduls in das Verzeichnis /etc/fdfs und ändern Sie sie

# cd /softpackages/fastdfs-nginx-module-master/src

# cp mod_fastdfs.conf /etc/fdfs/

Ändern Sie die folgende Konfiguration, andere Standard

#Verbindungs-Timeout connect_timeout=10

Tracker Server
tracker_server=file.ljzsg.com:22122
# StorageServer-Standardport storage_server_port=23000

# Wenn die URI der Datei-ID /group** enthält, setzen Sie sie auf true
url_have_group_name = wahr

# Der Pfad store_path0 der Speicherkonfiguration muss mit dem in storage.conf store_path0=/ljzsg/fastdfs/file übereinstimmen.

⑥ Kopieren Sie einige FastDFS-Konfigurationsdateien in das Verzeichnis /etc/fdfs

# cd /softpackages/fastdfs-5.05/conf/

# cp anti-steal.jpg http.conf mime.types /etc/fdfs/

⑦ Konfigurieren Sie nginx und ändern Sie nginx.conf

# vim /usr/local/nginx/conf/nginx.conf

Ändern Sie die Konfiguration, andere Standardeinstellungen

Fügen Sie das Modul fastdfs-nginx zu Port 80 hinzu

Standort ~/Gruppe([0-9])/M00 {
 ngx_fastdfs_module;
}

Beachten:

Der Listening-Port-Wert 80 sollte http.server_port=80 in /etc/fdfs/storage.conf entsprechen (zuvor auf 80 geändert). Bei einem Wechsel auf einen anderen Port ist eine Vereinheitlichung und Öffnung des Ports in der Firewall erforderlich.

Wenn mehrere Gruppen vorhanden sind, konfigurieren Sie für die Standortkonfiguration den Standort ~/group([0-9])/M00. Wenn keine Gruppen vorhanden sind, ist keine Gruppe erforderlich.

⑧ Erstellen Sie einen Softlink im Dateispeicherverzeichnis /ljzsg/fastdfs/file und verknüpfen Sie ihn mit dem Verzeichnis, in dem die Daten tatsächlich gespeichert sind. Dieser Schritt kann weggelassen werden.

# ln -s /ljzsg/fastdfs/Datei/Daten/ /ljzsg/fastdfs/Datei/Daten/M00

⑨ Starten Sie nginx

# /usr/local/nginx/sbin/nginx

Die Konfiguration ist erfolgreich, wenn der Druckort wie folgt ist

⑩ Besuchen Sie die Adressleiste.

Wenn Sie die Datei herunterladen können, war die Installation erfolgreich. Beachten Sie, dass im Gegensatz zur direkten Verwendung des Nginx-Routing-Zugriffs im dritten Punkt das Modul fastdfs-nginx-module hier so konfiguriert ist, dass Dateilinks zum Abrufen von Dateien an den Quellserver umgeleitet werden.

http://file.ljzsg.com/group1/M00/00/00/wKgz6lnduTeAMdrcAAEoRmXZPp870.jpeg

Diagramm der endgültigen Bereitstellungsstruktur (gestohlenes Bild): Sie können die Umgebung gemäß der folgenden Struktur erstellen.

5. Java-Client

Nachdem die Dateisystemplattform erstellt wurde, müssen wir den Clientcode schreiben, um das Hoch- und Herunterladen im System zu implementieren. Hier ist nur ein einfacher Testcode.

1. Zuerst müssen Sie die Java-Entwicklungsumgebung für den FastDFS-Client erstellen

① Verwenden Sie Maven für die Abhängigkeitsverwaltung im Projekt. Sie können die folgenden Abhängigkeiten in pom.xml einführen:

<Abhängigkeit>
 <groupId>net.oschina.zcx7878</groupId>
 <artifactId>fastdfs-client-java</artifactId>
 <version>1.27.0.0</version>
</Abhängigkeit>

Weitere Methoden finden Sie in der offiziellen Dokumentation: https://github.com/happyfish100/fastdfs-client-java

② Konfigurationsdateien importieren

Sie können fastdfs-client.properties.sample oder fdfs_client.conf.sample im Paket direkt in Ihr Projekt kopieren und .sample entfernen.

Hier kopiere ich die Konfiguration in fastdfs-client.properties.sample direkt in die Projektkonfigurationsdatei config.properties und ändere tracker_servers. Laden Sie einfach diese Konfigurationsdatei

2. Client-API

Persönlich gepackte FastDFS Java API wird mit GitHub synchronisiert: https://github.com/bojiangzhou/lyyzoo-fastdfs-java.git

6. Berechtigungskontrolle

Zuvor wurde nginx verwendet, um den HTTP-Dateizugriff zu unterstützen, aber jeder kann direkt auf diesen Dateiserver zugreifen, sodass eine gewisse Berechtigungskontrolle erfolgt.

Die Berechtigungssteuerung von FastDFS dient dazu, die Token-Verifizierung auf der Serverseite zu ermöglichen. Der Client erhält das Token basierend auf dem Dateinamen, dem aktuellen Unix-Zeitstempel und dem geheimen Schlüssel. Auf die Datei kann über http zugegriffen werden, indem der Adresse der Token-Parameter hinzugefügt wird.

① Aktivieren Sie die Token-Verifizierung auf dem Server

Ändern Sie http.conf
# vim /etc/fdfs/http.conf

Auf „true“ setzen, um die Token-Verifizierung zu aktivieren: http.anti_steal.check_token=true Legen Sie die Ablaufzeit des Tokens in Sekunden (s) fest: http.anti_steal.token_ttl=1800
Der Schlüssel sollte mit fastdfs.http_secret_key in der Client-Konfigurationsdatei http.anti_steal.secret_key=FASTDFS1234567890 übereinstimmen.

Wenn die Token-Prüfung fehlschlägt, lautet die zurückgegebene Seite http.anti_steal.token_check_fail=/ljzsg/fastdfs/page/403.html

Denken Sie daran, den Dienst neu zu starten.

② Konfigurieren Sie den Client

Der Client muss nur die folgenden beiden Parameter festlegen und die Schlüssel auf beiden Seiten bleiben konsistent.

# Token-Anti-Hotlink-Funktion
fastdfs.http_anti_steal_token=true
# Schlüssel
fastdfs.http_secret_key=FASTDFS1234567890

③ Der Client generiert ein Token

Um auf die Datei zuzugreifen, müssen Sie das generierte Token und den Unix-Zeitstempel mitbringen, sodass das zurückgegebene Token die Verkettung des Tokens und des Zeitstempels ist.

Anschließend können Sie darauf zugreifen, indem Sie das Token an die Adresse anhängen: file.ljzsg.com/group1/M00/00/00/wKgzgFnkaXqAIfXyAAEoRmXZPp878.jpeg?token=078d370098b03e9020b82c829c205e1f&ts=1508141521

/**
  * Holen Sie sich das Token für den Zugriff auf den Server und fügen Sie es der Adresse hinzu*
  * @param filepath Dateipfad group1/M00/00/00/wKgzgFnkTPyAIAUGAAEoRmXZPp876.jpeg
  * @param httpSecretKey Schlüssel * @return Token zurückgeben, wie zum Beispiel: token=078d370098b03e9020b82c829c205e1f&ts=1508141521
  */
 öffentliche statische String getToken(String Dateipfad, String httpSecretKey){
  // Unix Sekunden
  int ts = (int) Instant.now().getEpochSecond();
  //Zeichen
  Zeichenfolgentoken = "null";
  versuchen {
   token = ProtoCommon.getToken(getFilename(Dateipfad), ts, httpSecretKey);
  } Fang (UnsupportedEncodingException e) {
   e.printStackTrace();
  } Fang (NoSuchAlgorithmException e) {
   e.printStackTrace();
  } Fang (MeineAusnahme e) {
   e.printStackTrace();
  }

  StringBuilder sb = neuer StringBuilder();
  sb.anhängen("token=").anhängen(token);
  sb.anhängen("&ts=").anhängen(ts);

  gibt sb.toString() zurück;
 }

④ Hinweise

Wenn die Überprüfung des generierten Tokens fehlschlägt, führen Sie bitte die folgenden beiden Prüfungen durch:
A. Bestätigen Sie, dass die Token-Generierungsfunktion (ProtoCommon.getToken) aufgerufen wird und die übergebene Datei-ID nicht den Gruppennamen enthält. Das Format der übertragenen Datei-ID ist wie folgt: M00/00/00/wKgzgFnkTPyAIAUGAAEoRmXZPp876.jpeg

B. Stellen Sie sicher, dass die Serverzeit grundsätzlich konsistent ist. Beachten Sie, dass die Serverzeit nicht zu stark abweichen darf und nicht auf Minutenebene abweichen sollte.

⑤ Im Vergleich dazu können Sie, wenn die Systemdateien einen hohen Datenschutz aufweisen, direkt über die vom Fastdfs-Client bereitgestellte API auf sie zugreifen, ohne Nginx für den Zugriff über http konfigurieren zu müssen. Der Hauptzweck der Konfiguration von Nginx besteht darin, schnell auf Serverdateien (z. B. Bilder) zuzugreifen. Wenn auch eine Berechtigungsüberprüfung erforderlich ist, muss der Client ein Token generieren, was eigentlich bedeutungslos ist.

Der Punkt ist, ich habe nicht herausgefunden, wie FastDFS einigen Ressourcen eine Token-Verifizierung hinzufügen und sie teilweise öffnen kann. Wenn es jemand weiß, hinterlassen Sie bitte eine Nachricht.

OK, oben steht der Vorgang, bei dem FastDFS zum Erstellen eines Dateisystems und zum Hoch- und Herunterladen auf einer einzelnen Maschine verwendet wird.