One place for hosting & domains

      Installieren und Konfigurieren von Zabbix zur sicheren Überwachung von Remoteservern unter Ubuntu 20.04


      Der Autor wählte das Computer History Museum, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Zabbix ist eine Open-Source-basierte Überwachungssoftware für Netzwerke und Anwendungen. Sie ermöglicht eine Echtzeitüberwachung von Tausenden von Metriken, die von Servern und virtuellen Maschinen, Netzwerkgeräten und Webanwendungen gesammelt werden. Diese Metriken können Ihnen helfen, den aktuellen Status Ihrer IT-Infrastruktur zu ermitteln und Probleme mit Hardware- oder Softwarekomponenten zu erkennen, bevor sich Kunden beschweren. Nützliche Informationen werden in einer Datenbank gespeichert, damit Sie diese im Laufe der Zeit analysieren und die Qualität der bereitgestellten Dienste verbessern oder Upgrades für Ihre Geräte planen können.

      Zabbix verwendet verschiedene Optionen zum Sammeln von Metriken, darunter Überwachung ohne Agent von Benutzerdiensten und Client-Server-Architektur. Um Servermetriken zu sammeln, gibt es auf dem überwachten Client einen kleinen Agenten zum Erfassen von Daten und Senden dieser Daten an den Zabbix-Server. Zabbix unterstützt verschlüsselte Kommunikation zwischen dem Server und verbundenen Clients. So werden Ihre Daten geschützt, wenn sie über unsichere Netzwerke übertragen werden.

      Der Zabbix-Server speichert seine Daten in einer relationalen Datenbank, die auf MySQL oder PostgreSQL basiert. Außerdem können Sie historische Daten in NoSQL-Datenbanken wie Elasticsearch und TimescaleDB speichern. Zabbix bietet eine Weboberfläche, mit der Sie Daten anzeigen und Systemeinstellungen konfigurieren können.

      In diesem Tutorial konfigurieren Sie Zabbix auf zwei Ubuntu 20.04-Rechnern. Einer wird als Zabbix-Server konfiguriert, der andere als Client, den Sie überwachen möchten. Der Zabbix-Server wird eine MySQL-Datenbank nutzen, um Überwachungsdaten zu erfassen, und Nginx zur Bereitstellung der Weboberfläche verwenden.

      Voraussetzungen

      Um dieser Anleitung zu folgen, benötigen Sie:

      • Zwei Ubuntu 20.04-Server, die gemäß des Leitfadens zur Ersteinrichtung des Servers für Ubuntu 20.04 eingerichtet wurden, einschließlich eines Nicht-root-Benutzers, der über sudo-Berechtigungen verfügt, und einer mit ufw konfigurierten Firewall. Auf einem Server installieren Sie Zabbix; in diesem Tutorial wird dieser Server als Zabbix-Server bezeichnet. Er wird Ihren zweiten Server überwachen; dieser zweite Server wird als zweiter Ubuntu-Server bezeichnet.

      • Der Server, auf dem der Zabbix-Server ausgeführt wird, setzt installiertes Nginx, MySQL und PHP voraus. Folgen Sie Schritt 1-3 unserer Anleitung zum Ubuntu 20.04-LEMP-Stack, um diese Anwendungen auf Ihrem Zabbix-Server zu konfigurieren.

      • Einen registrierten Domänennamen. Dieses Tutorial verwendet in allen Bereichen your_domain. Sie können einen Domänennamen unter Namecheap erwerben oder einen kostenlosen von Freenom herunterladen oder einfach die Domänenregistrierungsstelle Ihrer Wahl verwenden.

      • Die beiden folgenden DNS-Einträge, eingerichtet für Ihren Zabbix-Server. Wenn Sie DigitalOcean verwenden, lesen Sie bitte unsere DNS Dokumentation für Details, wie Sie sie hinzufügen.

        • Einen A-Datensatz, wobei your_domain auf die öffentliche IP-Adresse Ihres Zabbix-Servers verweist.
        • Einen A-Datensatz, wobei www.your_domain auf die öffentliche IP-Adresse Ihres Zabbix-Servers verweist.

      Da der Zabbix-Server dazu dient, wertvolle Informationen über Ihre Infrastruktur aufzurufen, auf die nicht autorosierte Benutzer nicht zugreifen sollen, sollten Sie Ihren Server unbedingt schützen, indem Sie ein TLS/SSL-Zertifikat installieren. Dieser Schutz ist optional, wird jedoch ausdrücklich empfohlen. Wenn Sie Ihren Server schützen möchten, folgen Sie nach Schritt 3 dieses Tutorials dem Leitfaden Let’s Encrypt unter Ubuntu 20.04.

      Schritt 1 — Installieren des Zabbix-Servers

      Zuerst müssen Sie Zabbix auf dem Server installieren, auf dem Sie MySQL, Nginx und PHP installiert haben. Melden Sie sich bei diesem Rechner als Ihr non-root user an:

      • ssh sammy@zabbix_server_ip_address

      Zabbix ist im Paketmanager von Ubuntu verfügbar, ist jedoch veraltet. Verwenden Sie daher das offizielle Ubuntu-Repository zum Installieren der neuesten stabilen Version. Laden Sie das Repository-Konfigurationspaket herunter und installieren Sie es:

      • wget https://repo.zabbix.com/zabbix/5.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_5.0-1+focal_all.deb
      • sudo dpkg -i zabbix-release_5.0-1+focal_all.deb

      Sie sehen die folgende Ausgabe:

      Output

      Selecting previously unselected package zabbix-release. (Reading database ... 64058 files and directories currently installed.) Preparing to unpack zabbix-release_5.0-1+focal_all.deb ... Unpacking zabbix-release (1:5.0-1+focal) ... Setting up zabbix-release (1:5.0-1+focal) ...

      Aktualisieren Sie den Paketindex, sodass das neue Repository enthalten ist:

      Installieren Sie dann den Zabbix-Server und das Web-Frontend mit Unterstützung der MySQL-Datenbank:

      • sudo apt install zabbix-server-mysql zabbix-frontend-php

      Installieren Sie außerdem den Zabbix-Agenten, mit dem Sie Daten über den Status des Zabbix-Servers selbst sammeln können.

      • sudo apt install zabbix-agent

      Bevor Sie Zabbix nutzen können, müssen Sie eine Datenbank einrichten, um die Daten zu speichern, die der Zabbix-Server von seinen Agenten erfassen wird. Sie können dies im nächsten Schritt tun.

      Schritt 2 — Konfigurieren der MySQL-Datenbank für Zabbix

      Sie müssen eine neue MySQL-Datenbank erstellen und sie mit einigen grundlegenden Daten befüllen, um sie bereit für Zabbix zu machen. Außerdem erstellen Sie einen bestimmten Benutzer für diese Datenbank, damit Zabbix sich nicht mit dem root-Konto bei MySQL anmeldet.

      Melden Sie sich als root user bei MySQL an:

      Erstellen Sie die Zabbix-Datenbank mit Unterstützung für UTF-8-Zeichen:

      • create database zabbix character set utf8 collate utf8_bin;

      Erstellen Sie dann einen Benutzer, den der Zabbix-Server verwenden wird, gewähren Sie ihm Zugriff auf die neue Datenbank und legen Sie das Passwort für den Benutzer fest:

      • create user zabbix@localhost identified by 'your_zabbix_mysql_password';
      • grant all privileges on zabbix.* to zabbix@localhost;

      Damit sind der Benutzer und die Datenbank einsatzbereit. Beenden Sie die Datenbankkonsole.

      Als Nächstes müssen Sie das erste Schema und die Daten importieren. Die Zabbix-Installation bietet Ihnen eine Datei, die diese Einrichtung übernimmt.

      Führen Sie folgenden Befehl aus, um das Schema einzurichten und die Daten in die zabbix-Datenbank zu importieren. Verwenden Sie zcat, da die Daten in der Datei komprimiert sind:

      • zcat /usr/share/doc/zabbix-server-mysql*/create.sql.gz | mysql -uzabbix -p zabbix

      Geben Sie das Passwort für den von Ihnen konfigurierten zabbix-MySQL-Benutzer ein, wenn Sie dazu aufgefordert werden.

      Die Ausführung des Befehls kann eine oder zwei Minuten dauern. Wenn Sie den Fehler ERROR 1045 (28000): Access denied for userzabbix@'localhost' (using password: YES) erhalten, sollten Sie sich vergewissern, dass Sie das richtige Passwort für den zabbix verwendet haben.

      Damit der Zabbix-Server diese Datenbank nutzt, müssen Sie in der Konfigurationsdatei für den Zabbix-Server das Datenbankpasswort festlegen. Öffnen Sie die Konfigurationsdatei in Ihrem bevorzugten Editor. Dieses Tutorial verwendet nano:

      • sudo nano /etc/zabbix/zabbix_server.conf

      Suchen Sie nach dem folgenden Abschnitt der Datei:

      /etc/zabbix/zabbix_server.conf

      ...
      ### Option: DBPassword                           
      #       Database password. Ignored for SQLite.   
      #       Comment this line if no password is used.
      #                                                
      # Mandatory: no                                  
      # Default:                                       
      # DBPassword=
      ...
      

      Diese Kommentare in der Datei erklären, wie Sie eine Verbindung mit der Datenbank herstellen können. Sie müssen den Wert von DBPassword in der Datei auf das Passwort für Ihren Datenbankbenutzer setzen. Fügen Sie die Zeile nach den Kommentaren hinzu, um die Datenbank zu konfigurieren:

      /etc/zabbix/zabbix_server.conf

      ...
      DBPassword=your_zabbix_mysql_password
      ...
      

      Speichern und schließen Sie zabbix_server.conf, indem Sie Strg+X drücken, gefolgt von Y und dann der Eingabetaste, wenn Sie nano verwenden.

      Sie haben den Zabbix-Server nun so konfiguriert, dass er eine Verbindung zur Datenbank herstellt. Als Nächstes konfigurieren Sie den Nginx-Webserver, um das Zabbix-Frontend bereitzustellen.

      Schritt 3 — Konfigurieren von Nginx für Zabbix

      Installieren Sie das automatische Konfigurationspaket, um Nginx automatisch zu konfigurieren:

      • sudo apt install zabbix-nginx-conf

      Dadurch erhalten Sie die Konfigurationsdatei /etc/zabbix/nginx.conf sowie einen Link dahin im Nginx-Konfigurationsverzeichnis /etc/nginx/conf.d/zabbix.conf.

      Als Nächstes müssen Sie Änderungen an dieser Datei vornehmen. Öffnen Sie die Konfigurationsdatei:

      • sudo nano /etc/zabbix/nginx.conf

      Die Datei enthält eine automatisch generierte Nginx-Serverblock-Konfiguration. Sie enthält zwei Zeilen, die den Namen des Servers bestimmen und festlegen, an welchem Port er lauscht:

      /etc/zabbix/nginx.conf

      server {
      #        listen          80;
      #        server_name     example.com;
      ...
      

      Heben Sie die Kommentierung der beiden Zeilen auf und ersetzen Sie example.com durch Ihren Domänennamen. Ihre Einstellungen werden wie folgt aussehen:

      /etc/zabbix/nginx.conf

      server {
              listen          80;
              server_name     your_domain;
      ...
      

      Speichern und schließen Sie die Datei. Als Nächstes testen Sie, um sicherzustellen, dass es in keiner Ihrer Nginx-Dateien Syntaxfehler gibt, und laden Sie die Konfiguration neu:

      • sudo nginx -t
      • sudo nginx -s reload

      Nachdem Nginx so eingerichtet ist, dass das Zabbix-Frontend bereitgestellt wird, werden Sie nun einige Änderungen an Ihrer PHP-Einrichtung vornehmen, damit die Zabbix-Weboberfläche ordnungsgemäß funktioniert.

      Anmerkung: Wie im Voraussetzungsbereich erwähnt, sollten Sie auf Ihrem Server SSL/TLS aktivieren. Wenn Sie dies tun möchten, folgen Sie unserem Ubuntu 20.04-Tutorial für Let’s Encrypt, bevor Sie mit Schritt 4 fortfahren, um ein kostenloses SSL-Zertifikat für Nginx zu erhalten. Dieser Prozess wird Ihren Zabbix-Serverblock automatisch erkennen und ihn für HTTPS konfigurieren. Nach der Erlangung Ihrer SSL/TLS-Zertifikate können Sie zurückkehren und dieses Tutorial abschließen.

      Schritt 4 — Konfigurieren von PHP für Zabbix

      Die Zabbix-Weboberfläche ist in PHP geschrieben und erfordert einige spezielle PHP-Servereinstellungen. Der Zabbix-Installationsprozess hat eine PHP-FPM-Konfigurationsdatei erstellt, die diese Einstellungen enthält. Sie befindet sich im Verzeichnis /etc/zabbix und wird von PHP-FPM automatisch geladen. Sie müssen eine kleine Änderung in dieser Datei vornehmen; öffnen Sie sie also folgendermaßen:

      • sudo nano /etc/zabbix/php-fpm.conf

      Die Datei enthält PHP-Einstellungen, die die erforderlichen Anforderungen für die Zabbix-Weboberfläche erfüllen. Die Einstellung der Zeitzone ist jedoch standardmäßig auskommentiert. Um sicherzustellen, dass Zabbix die richtige Zeit verwendet, müssen Sie die richtige Zeitzone festlegen:

      /etc/zabbix/php-fpm.conf

      ...
      php_value[max_execution_time] = 300
      php_value[memory_limit] = 128M
      php_value[post_max_size] = 16M
      php_value[upload_max_filesize] = 2M
      php_value[max_input_time] = 300
      php_value[max_input_vars] = 10000
      ; php_value[date.timezone] = Europe/Riga
      

      Heben Sie die Kommentierung der im vorigen Codeblock markierten Zeitzonenzeile auf und ändern Sie sie in Ihre Zeitzone. Sie können diese Liste der unterstützten Zeitzonen verwenden, um die richtige für Sie zu finden. Speichern und schließen Sie die Datei.

      Starten Sie PHP-FPM nun neu, um die neuen Einstellungen anzuwenden:

      • sudo systemctl restart php7.4-fpm.service

      Sie können den Zabbix-Server nun starten:

      • sudo systemctl start zabbix-server

      Überprüfen Sie dann, ob der Zabbix-Server ordnungsgemäß ausgeführt wird:

      • sudo systemctl status zabbix-server

      Sie werden den folgenden Status sehen:

      Output

      ● zabbix-server.service - Zabbix Server Loaded: loaded (/lib/systemd/system/zabbix-server.service; disabled; vendor preset: enabled) Active: active (running) since Fri 2020-06-12 05:59:32 UTC; 36s ago Process: 27026 ExecStart=/usr/sbin/zabbix_server -c $CONFFILE (code=exited, status=0/SUCCESS) ...

      Aktivieren Sie den Server abschließend so, dass er beim Booten gestartet wird:

      • sudo systemctl enable zabbix-server

      Der Server ist eingerichtet und mit der Datenbank verbunden. Erstellen Sie als Nächstes das Web-Frontend.

      Schritt 5 — Konfigurieren von Einstellungen für die Zabbix-Weboberfläche

      Mit der Weboberfläche können Sie Berichte anzeigen und Hosts hinzufügen, die Sie überwachen möchten. Dies muss jedoch vor der Verwendung eingerichtet werden. Starten Sie dazu Ihren Browser und rufen Sie die Adresse http://zabbix_server_name oder https://zabbix_server_name auf, wenn Sie Let’s Encrypt verwenden. Im ersten Bildschirm sehen Sie eine Willkommensnachricht. Klicken Sie auf Nächster Schritt um fortzufahren.

      Im nächsten Bildschirm sehen Sie die Tabelle, die alle Voraussetzungen zur Ausführung von Zabbix auflistet.

      Voraussetzungen

      Alle Werte in dieser Tabelle müssen OK sein. Überprüfen Sie also, ob sie es sind. Stellen Sie sicher, dass Sie nach unten scrollen und alle Voraussetzungen ansehen. Sobald Sie geprüft haben, ob alles bereit ist, klicken Sie auf Nächster Schritt um fortzufahren.

      Der nächste Bildschirm bittet um Informationen zur Datenbankverbindung.

      DB-Verbindung

      Sie haben den Zabbix-Server über Ihre Datenbank informiert. Die Zabbix-Weboberfläche benötigt jedoch auch Zugriff auf die Datenbank, um Hosts verwalten und Daten lesen zu können. Geben Sie daher die MySQL-Anmeldedaten ein, die Sie in Schritt 2 konfiguriert haben. Klicken Sie auf Nächster Schritt um fortzufahren.

      Im nächsten Bildschirm können Sie die Optionen bei ihren Standardwerten belassen.

      Zabbix Server-Details

      Der Name ist optional; er wird in der Weboberfläche verwendet, um einen Server vom anderen zu unterscheiden, falls Sie über mehrere Überwachungsserver verfügen. Klicken Sie auf Nächster Schritt um fortzufahren.

      Im nächsten Bildschirm wird die Zusammenfassung vor der Installation angezeigt, sodass Sie prüfen können, ob alles korrekt ist.

      Zusammenfassung

      Klicken Sie auf Nächster Schritt, um mit dem letzten Bildschirm fortzufahren.

      Die Einrichtung der Weboberfläche ist nun abgeschlossen. Dieser Prozess erstellt die Konfigurationsdatei /usr/share/zabbix/conf/zabbix.conf.php, die Sie sichern und in Zukunft verwenden können. Klicken Sie auf Fertig stellen, um mit dem Anmeldebildschirm fortzufahren. Der Standardbenutzer ist Admin und das Passwort lautet zabbix.

      Richten Sie, bevor Sie sich anmelden, den Zabbix-Agenten auf Ihrem zweiten Ubuntu-Server ein.

      Schritt 6 — Installieren und Konfigurieren des Zabbix-Agenten

      Jetzt müssen Sie die Agentensoftware konfigurieren, die Überwachungsdaten an den Zabbix-Server senden wird.

      Melden Sie sich beim zweiten Ubuntu-Server an:

      • ssh sammy@second_ubuntu_server_ip_address

      Führen Sie wie auf dem Zabbix-Server die folgenden Befehle aus, um das Repository-Konfigurationspaket zu installieren:

      • wget https://repo.zabbix.com/zabbix/5.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_5.0-1+focal_all.deb
      • sudo dpkg -i zabbix-release_5.0-1+focal_all.deb

      Aktualisieren Sie als Nächstes den Paketindex:

      Installieren Sie dann den Zabbix-Agenten:

      • sudo apt install zabbix-agent

      Zwar unterstützt Zabbix zertifikatbasierte Verschlüsselung, doch ist die Einrichtung einer Zertifizierungsstelle nicht Teil dieses Tutorials. Sie können jedoch Pre-Shared Keys (PSK) verwenden, um die Verbindung zwischen dem Server und Agenten zu sichern.

      Erstellen Sie zunächst einen PSK:

      • sudo sh -c "openssl rand -hex 32 > /etc/zabbix/zabbix_agentd.psk"

      Zeigen Sie den Schlüssel mit cat an, damit Sie ihn kopieren können:

      • cat /etc/zabbix/zabbix_agentd.psk

      Der Schlüssel wird in etwa so aussehen:

      Output

      75ad6cb5e17d244ac8c00c96a1b074d0550b8e7b15d0ab3cde60cd79af280fca

      Speichern Sie ihn für später; Sie brauchen ihn noch, um den Host konfigurieren.

      Bearbeiten Sie nun die Zabbix-Agenteneinstellungen, um die sichere Verbindung zum Zabbix-Server einzurichten. Öffnen Sie die Konfigurationsdatei für den Agenten in Ihrem Texteditor:

      • sudo nano /etc/zabbix/zabbix_agentd.conf

      Jede Einstellung innerhalb dieser Datei wird über informative Kommentare in der Datei dokumentiert; Sie müssen jedoch nur einige von ihnen bearbeiten.

      Zuerst müssen Sie die IP-Adresse des Zabbix-Servers bearbeiten. Suchen Sie nach dem folgenden Abschnitt:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: Server
      #       List of comma delimited IP addresses, optionally in CIDR notation, or DNS names of Zabbix servers and Zabbix proxies.
      #       Incoming connections will be accepted only from the hosts listed here.
      #       If IPv6 support is enabled then '127.0.0.1', '::127.0.0.1', '::ffff:127.0.0.1' are treated equally
      #       and '::/0' will allow any IPv4 or IPv6 address.
      #       '0.0.0.0/0' can be used to allow any IPv4 address.
      #       Example: Server=127.0.0.1,192.168.1.0/24,::1,2001:db8::/32,zabbix.example.com
      #
      # Mandatory: yes, if StartAgents is not explicitly set to 0
      # Default:
      # Server=
      
      Server=127.0.0.1
      ...
      

      Ändern Sie den Standardwert in die IP-Adresse Ihres Zabbix-Servers:

      /etc/zabbix/zabbix_agentd.conf

      ...
      Server=zabbix_server_ip_address
      ...
      

      Standardmäßig verbindet sich der Zabbix-Server mit dem Agenten. Bei einigen Überprüfungen (z. B. Überwachung der Protokolle) ist jedoch eine umgekehrte Verbindung erforderlich. Für eine korrekte Funktionsweise müssen Sie die Adresse des Zabbix-Servers und einen eindeutigen Hostnamen angeben.

      Finden Sie den Abschnitt, der die aktiven Prüfungen konfiguriert, und ändern Sie die Standardwerte:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ##### Active checks related
      
      ### Option: ServerActive
      #       List of comma delimited IP:port (or DNS name:port) pairs of Zabbix servers and Zabbix proxies for active checks.
      #       If port is not specified, default port is used.
      #       IPv6 addresses must be enclosed in square brackets if port for that host is specified.
      #       If port is not specified, square brackets for IPv6 addresses are optional.
      #       If this parameter is not specified, active checks are disabled.
      #       Example: ServerActive=127.0.0.1:20051,zabbix.domain,[::1]:30051,::1,[12fc::1]
      #
      # Mandatory: no
      # Default:
      # ServerActive=
      
      ServerActive=zabbix_server_ip_address
      
      ### Option: Hostname
      #       Unique, case sensitive hostname.
      #       Required for active checks and must match hostname as configured on the server.
      #       Value is acquired from HostnameItem if undefined.
      #
      # Mandatory: no
      # Default:
      # Hostname=
      
      Hostname=Second Ubuntu Server
      ...
      

      Suchen Sie als Nächstes nach dem Bereich, der die sichere Verbindung mit dem Zabbix-Server konfiguriert, und aktivieren Sie PSK-Unterstützung. Finden Sie den Abschnitt TLSConnect, der so aussieht:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSConnect
      #       How the agent should connect to server or proxy. Used for active checks.
      #       Only one value can be specified:
      #               unencrypted - connect without encryption
      #               psk         - connect using TLS and a pre-shared key
      #               cert        - connect using TLS and a certificate
      #
      # Mandatory: yes, if TLS certificate or PSK parameters are defined (even for 'unencrypted' connection)
      # Default:
      # TLSConnect=unencrypted
      ...
      

      Fügen Sie dann diese Zeile hinzu, um PSK-Unterstützung zu konfigurieren:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSConnect=psk
      ...
      

      Suchen Sie als Nächstes den Abschnitt TLSAccept, der so aussieht:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSAccept
      #       What incoming connections to accept.
      #       Multiple values can be specified, separated by comma:
      #               unencrypted - accept connections without encryption
      #               psk         - accept connections secured with TLS and a pre-shared key
      #               cert        - accept connections secured with TLS and a certificate
      #
      # Mandatory: yes, if TLS certificate or PSK parameters are defined (even for 'unencrypted' connection)
      # Default:
      # TLSAccept=unencrypted
      ...
      

      Konfigurieren Sie eingehende Verbindungen so, dass sie Pre-Shared Keys unterstützen, indem Sie folgende Zeile hinzufügen:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSAccept=psk
      ...
      

      Suchen Sie als Nächstes den Abschnitt TLSPSKIdentity, der so aussieht:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSPSKIdentity
      #       Unique, case sensitive string used to identify the pre-shared key.
      #
      # Mandatory: no
      # Default:
      # TLSPSKIdentity=
      ...
      

      Wählen Sie einen eindeutigen Namen, um Ihren Pre-Shared Key zu identifizieren, indem Sie diese Zeile hinzufügen:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSPSKIdentity=PSK 001
      ...
      

      Sie werden ihn als PSK ID verwenden, wenn Sie Ihren Host über die Zabbix-Weboberfläche hinzufügen.

      Legen Sie dann die Option fest, die auf Ihren zuvor erstellten Pre-Shared Key verweist. Suchen Sie nach der Option TLSPSKFile:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSPSKFile
      #       Full pathname of a file containing the pre-shared key.
      #
      # Mandatory: no
      # Default:
      # TLSPSKFile=
      ...
      

      Fügen Sie diese Zeile hinzu, um den Zabbix-Agent auf die von Ihnen erstellte PSK-Datei zu verweisen:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSPSKFile=/etc/zabbix/zabbix_agentd.psk
      ...
      

      Speichern und schließen Sie die Datei. Jetzt können Sie den Zabbix-Agenten neu starten und ihn so einrichten, dass er beim Booten gestartet wird:

      • sudo systemctl restart zabbix-agent
      • sudo systemctl enable zabbix-agent

      Überprüfen Sie zur Sicherheit, ob der Zabbix-Agent ordnungsgemäß ausgeführt wird:

      • sudo systemctl status zabbix-agent

      Sie werden den folgenden Status sehen, was zeigt, dass der Agent ausgeführt wird:

      Output

      ● zabbix-agent.service - Zabbix Agent Loaded: loaded (/lib/systemd/system/zabbix-agent.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2020-06-12 08:19:54 UTC; 25s ago ...

      Der Agent wird an Port 10050 nach Verbindungen vom Server lauschen. Konfigurieren Sie UFW so, dass Verbindungen zu diesem Port zugelassen werden:

      Mehr über UFW erfahren Sie in Einrichten einer Firewall mit UFW unter Ubuntu 20.04.

      Ihr Agent ist nun bereit, Daten an den Zabbix-Server zu senden. Um ihn verwenden zu können, müssen Sie ihn jedoch noch über die Webkonsole des Servers verlinken. Im nächsten Schritt werden Sie die Konfiguration abschließen.

      Schritt 7 — Hinzufügen des neuen Host zum Zabbix-Server

      Die Installation des Agenten auf einem Server, den Sie überwachen möchten, ist nur die halbe Arbeit. Jeder Host, den Sie überwachen möchten, muss beim Zabbix-Server registriert werden. Das können Sie über die Weboberfläche tun.

      Melden Sie sich bei der Weboberfläche des Zabbix-Servers an, indem Sie zur Adresse http://zabbix_server_name oder https://zabbix_server_name navigieren:

      Der Zabbix-Anmeldebildschirm

      Nachdem Sie sich angemeldet haben, klicken Sie auf Konfiguration und dann in der linken Navigationsleiste auf Hosts. Klicken Sie dann in der rechten oberen Ecke des Bildschirms auf die Schaltfläche Host erstellen. Dadurch wird die Hostkonfigurationsseite geöffnet.

      Erstellen eines Hosts

      Passen Sie den Hostnamen und die IP-Adresse so an, dass sie den Hostnamen und die IP-Adresse Ihres zweiten Ubuntu-Servers widerspiegeln. Fügen Sie den Host dann einer Gruppe hinzu. Sie können eine bestehende Gruppe auswählen, z. B. Linux-Server, oder eine eigene Gruppe erstellen. Der Host kann Mitglied in mehreren Gruppen sein. Geben Sie dazu den Namen einer bestehenden oder neuen Gruppe im Feld Gruppen ein und wählen Sie den gewünschten Wert aus der vorgeschlagenen Liste aus.

      Klicken Sie vor dem Hinzufügen der Gruppe auf die Registerkarte Vorlagen.

      Hinzufügen einer Vorlage zum Host

      Geben Sie im Suchfeld Template OS Linux by Zabbix agent ein und wählen Sie dann die Vorlage aus der Liste aus, um sie dem Host hinzuzufügen.

      Navigieren Sie als Nächstes zur Registerkarte Verschlüsselung. Wählen Sie sowohl für Verbindungen zu Host als auch für Verbindungen von Host PSK aus. Setzen Sie dann die PSK-Identität auf PSK 001, was der Wert der zuvor konfigurierten TLSPSKIdentity-Einstellung des Zabbix-Agenten ist. Setzen Sie dann den PSK-Wert auf den Schlüssel, den Sie für den Zabbix-Agenten generiert haben. Es ist der Wert, den Sie in der Datei /etc/zabbix/zabbix_agentd.psk auf dem Agentengerät gespeichert haben.

      Einrichten der Verschlüsselung

      Klicken Sie abschließend unten im Formular auf die Schaltfläche Hinzufügen, um den Host zu erstellen.

      Sie werden Ihren neuen Host in der Liste sehen. Warten Sie eine Minute lang und laden Sie die Seite neu, bis Sie grüne Markierungen sehen, was bedeutet, dass alles ordnungsgemäß funktioniert und die Verbindung verschlüsselt ist.

      Zabbix zeigt Ihren neuen Host

      Wenn Sie zusätzliche Server haben, die Sie überwachen möchten, müssen Sie sich bei jedem Host anmelden, den Zabbix-Agenten installieren, einen PSK generieren, den Agenten konfigurieren und den Host zur Weboberfläche hinzufügen (genauso wie beim ersten Host).

      Der Zabbix-Server überwacht nun Ihren zweiten Ubuntu-Server. Erstellen Sie nun E-Mail-Benachrichtigungen, um über Probleme informiert zu werden.

      Schritt 8 — Konfigurieren von E-Mail-Benachrichtigungen

      Zabbix unterstützt automatisch verschiedene Arten von Benachrichtigungen: E-Mail, OTRS, Slack, Telegram, SMS etc. Eine vollständige Liste von Integrationen finden Sie auf der Zabbix-Website.

      Als Beispiel werden wir in diesem Tutorial Benachrichtigungen für den Medientyp E-Mail konfigurieren.

      Klicken Sie auf Administration und dann in der linken Navigationsleiste auf Medientypen. Sie werden eine Liste mit allen Medientypen sehen. Es gibt zwei vorkonfigurierte Optionen für E-Mails: für die Klartextbenachrichtigung und für die HTML-Benachrichtigungen. In diesem Tutorial werden Sie eine Klartextbenachrichtigung verwenden. Klicken Sie auf E-Mail.

      Passen Sie die SMTP-Optionen gemäß den Einstellungen Ihres E-Mail-Dienstes an. In diesem Tutorial werden SMTP-Funktionen von Gmail verwendet, um E-Mail-Benachrichtigungen einzurichten; wenn Sie weitere Informationen dazu wünschen, lesen Sie Verwenden des SMTP-Servers von Google.

      Anmerkung: Wenn Sie eine 2-Schritt-Verifizierung mit Gmail verwenden, müssen Sie ein App-Passwort für Zabbix generieren. Sie müssen bei der Einrichtung ein App-Passwort nur einmal eingeben. Anweisungen zum Generieren dieses Passworts finden Sie im Google Help Center.

      Wenn Sie Gmail verwenden, geben Sie smtp.gmail.com in das Feld SMTP-Server ein, 465 in das Feld SMTP-Serverport, gmail.com in SMTP helo und Ihre E-Mail-Adresse in SMTP-E-Mail. Wählen Sie dann SSL/TLS für Verbindungssicherheit und Benutzername und Passwort für Authentifizierung. Geben Sie Ihre Gmail-Adresse als Benutzernamen und das von Ihnen über Ihr Google-Konto generierte App-Passwort als Passwort ein.

      Einrichten des Medientyps E-Mail

      Auf der Registerkarte Nachrichtenvorlagen können Sie die Liste der vordefinierten Nachrichten für verschiedene Arten von Benachrichtigungen sehen. Klicken Sie abschließend unten im Formular auf die Schaltfläche Aktualisieren, um die E-Mail-Parameter zu aktualisieren.

      Jetzt können Sie das Senden von Benachrichtigungen testen. Klicken Sie dazu in der entsprechenden Zeile auf den unterstrichenen Link Testen.

      Sie werden ein Popup-Fenster sehen. Geben Sie Ihre E-Mail-Adresse in das Feld Senden an ein und klicken Sie auf Testen. Sie werden eine Nachricht zum erfolgreichen Versand sehen und eine Testnachricht erhalten.

      Testen von E-Mail

      Schließen Sie das Popup-Fenster durch Klicken auf die Schaltfläche Abbrechen.

      Erstellen Sie nun einen neuen Benutzer. Klicken Sie auf Administration und dann in der linken Navigationsleiste auf Benutzer. Sie werden die Liste der Benutzer sehen. Klicken Sie dann in der rechten oberen Ecke des Bildschirms auf die Schaltfläche Benutzer erstellen. Damit wird die Seite für die Benutzerkonfiguration geöffnet:

      Erstellen eines Benutzers

      Geben Sie den neuen Benutzernamen im Feld Alias ein und legen Sie ein neues Passwort fest. Fügen Sie als Nächstes den Benutzer zur Administratorgruppe hinzu. Geben Sie Zabbix administrators in das Feld Gruppen ein und wählen Sie die Gruppe aus der vorgeschlagenen Liste aus.

      Sobald Sie die Gruppe hinzugefügt haben, klicken Sie auf die Registerkarte Medien und dann auf den unterstrichenen Link Hinzufügen (nicht auf die Schaltfläche Hinzufügen darunter). Sie werden ein Popup-Fenster sehen.

      Hinzufügen einer E-Mail-Adresse

      Wählen Sie die Option E-Mail aus dem Dropdownmenü Typ aus. Geben Sie Ihre E-Mail-Adresse in das Feld Senden an ein. Sie können die restlichen Optionen bei ihren Standardwerten belassen. Klicken Sie unten zum Übermitteln auf die Schaltfläche Hinzufügen.

      Navigieren Sie nun zur Registerkarte Berechtigungen. Wählen Sie Zabbix Super Admin aus dem Dropdownmenü Benutzertyp aus.

      Klicken Sie abschließend unten im Formular auf die Schaltfläche Hinzufügen, um den Benutzer zu erstellen.

      Anmerkung: Eine Verwendung des Standardpassworts ist nicht sicher. Um das Passwort des integrierten Benutzers Admin zu ändern, klicken Sie in der Benutzerliste auf das entsprechende Alias. Klicken Sie dann auf Passwort ändern, geben Sie ein neues Passwort ein und bestätigen Sie die Änderung durch Klicken auf Aktualisieren.

      Jetzt müssen Sie Benachrichtigungen aktivieren. Klicken Sie auf die Registerkarte Konfiguration und dann in der linken Navigationsleiste auf Aktionen. Sie werden eine vorkonfigurierte Aktion sehen, die zum Senden von Benachrichtigungen an alle Zabbix-Administratoren dient. Sie können die Einstellungen überprüfen und ändern, indem Sie auf den Namen klicken. Verwenden Sie für die Zwecke dieses Tutorials die Standardparameter. Um die Aktion zu aktivieren, klicken Sie in der Spalte Status auf den roten Link für Deaktiviert.

      Jetzt sind Sie bereit dazu, Warnungen zu erhalten. Im nächsten Schritt werden Sie eine Warnung erstellen, um Ihre Benachrichtigungskonfiguration zu testen.

      Schritt 9 — Erstellen einer Testwarnung

      In diesem Schritt erstellen Sie eine Testwarnung, um sicherzustellen, dass alles richtig verbunden ist. Standardmäßig behält Zabbix den Überblick über die Menge an freien Speicherplatz auf Ihrem Server. Der Server erkennt automatisch alle bereitgestellten Datenträger und fügt die entsprechenden Prüfungen hinzu. Diese Erkennungsfunktion wird jede Stunde ausgeführt; Sie müssen also eine Weile warten, bis die Benachrichtigung ausgelöst wird.

      Erstellen Sie eine temporäre Datei, die groß genug ist, um die Zabbix-Warnung bei Auslastung des Dateisystems auszulösen. Melden Sie sich dazu bei Ihrem zweiten Ubuntu-Server an, wenn Sie nicht bereits verbunden sind:

      • ssh sammy@second_ubuntu_server_ip_address

      Überprüfen Sie als Nächstes den freien Speicherplatz auf dem Server. Sie können den Befehl df verwenden, um das herauszufinden:

      Der Befehl df wird die Auslastung des Datenträgers in Ihrem Dateisystem melden. Der Befehl -h wird die Ausgabe für Menschen lesbar machen. Sie sehen eine Ausgabe wie die folgende:

      Output

      Filesystem Size Used Avail Use% Mounted on /dev/vda1 78G 1.4G 77G 2% /

      In diesem Fall beträgt der freie Speicherplatz 77 GB. Ihr freier Speicherplatz kann sich davon unterscheiden.

      Verwenden Sie den Befehl fallocate, mit dem Sie den Speicherplatz für eine Datei vorab zuweisen oder freigeben können, um eine Datei zu erstellen, die mehr als 80 % des verfügbaren Speicherplatzes benötigt. Das wird ausreichen, um die Warnung auszulösen:

      • fallocate -l 70G /tmp/temp.img

      Nach etwa einer Stunde wird Zabbix eine Warnung zur Menge des freien Speicherplatzes auslösen und die von Ihnen konfigurierte Aktion ausführen (also die Benachrichtigungsmeldung senden). Sie können Ihren Posteingang auf die Nachricht vom Zabbix-Server prüfen. Sie werden eine Nachricht sehen, die wie folgt aussieht:

      Problem started at 09:49:08 on 2020.06.12
      Problem name: /: Disk space is low (used > 80%)
      Host: Second Ubuntu Server
      Severity: Warning
      Operational data: Space used: 71.34 GB of 77.36 GB (92.23 %)
      Original problem ID: 106
      

      Sie können auch zur Registerkarte Überwachung und dann zum Dashboard navigieren, um die Benachrichtigung und ihre Details anzuzeigen.

      Haupt-Dashboard

      Nachdem Sie nun wissen, dass die Warnungen funktionieren, löschen Sie die von Ihnen erstellte temporäre Datei, um den Speicherplatz wieder freizugeben:

      Nach einer Minute wird Zabbix die Wiederherstellungsnachricht senden und die Warnmeldung aus dem Haupt-Dashboard verschwindet.

      Zusammenfassung

      In diesem Tutorial haben Sie gelernt, wie Sie eine einfache und sichere Überwachungslösung einrichten können, die Ihnen bei der Überwachung des Status Ihrer Server hilft. Die Lösung kann Sie nun vor Problemen warnen und bietet Ihnen die Möglichkeit, die in Ihrer IT-Infrastruktur vorkommenden Prozesse zu analysieren.

      Um mehr über die Einrichtung einer Überwachungsinfrastruktur zu erfahren, lesen Sie unsere Seite zum Thema Überwachung.



      Source link

      Bereitstellen von Laravel 7 und MySQL in Kubernetes mithilfe von Helm


      Der Autor hat den Diversity in Tech Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Laravel ist heute eines der beliebtesten Open-Source-basierten PHP-Anwendungsframeworks. Es wird oft mit einer MySQL-Datenbank bereitgestellt, kann aber so konfiguriert werden, dass verschiedene Backend-Datenspeicheroptionen zum Einsatz kommen. Laravel ist stolz darauf, viele moderne Funktionen und das umfangreiche Paketökosystem von PHP zu nutzen.

      Kubernetes ist eine Plattform zur Orchestrierung von Containern, die in DigitalOcean Kubernetes-Clustern gehostet werden kann, um einen Großteil der Verwaltungsaufgaben bei der Einrichtung und Ausführung von Containern in der Produktion zu übernehmen. Helm ist ein Kubernetes-Paketmanager, der das Konfigurieren und Installieren von Diensten und Pods vereinfacht.

      In diesem Leitfaden erstellen Sie eine Laravel PHP-Anwendung, erstellen Ihre App in einem Docker-Image und stellen das Image mithilfe des LAMP Helm Chart in einem DigitalOcean Kubernetes-Cluster bereit. Als Nächstes richten Sie einen Ingress Controller ein, um Ihrer App SSL und einen benutzerdefinierten Domänennamen hinzuzufügen.Danach verfügen Sie eine funktionierende Laravel-Anwendung, die mit einer MySQL-Datenbank verbunden ist, die in einem Kubernetes-Cluster ausgeführt wird.

      Voraussetzungen

      • Docker, installiert auf dem Computer, von dem aus Sie auf Ihren Cluster zugreifen werden. Detaillierte Anweisungen zum Installieren von Docker für die meisten Linux-Distributionen finden Sie hier oder für andere Betriebssysteme auf der Website von Docker.
      • Ein Konto bei Docker Hub zur Speicherung von Docker-Images, die Sie in diesem Tutorial erstellen werden.
      • Einen DigitalOcean Kubernetes 1.17+-Cluster, bei dem Ihre Verbindung als der kubectl-Standard konfiguriert ist. Um zu erfahren, wie Sie einen Kubernetes-Cluster in DigitalOcean erstellen können, lesen Sie unser Dokument Kubernetes Schnellstart. Um zu erfahren, wie Sie eine Verbindung zum Cluster herstellen können, konsultieren Sie Herstellen einer Verbindung zu einem DigitalOcean Kubernetes-Cluster.
      • Helm 3-Paketmanager, auf Ihrem lokalen Rechner installiert. Führen Sie den ersten Schritt aus und fügen Sie das stable-Repository aus dem zweiten Schritt des Tutorials Installieren von Software in Kubernetes-Clustern mit dem Helm 3-Paketmanager hinzu.
      • Einen vollständig registrierten Domänennamen mit einem verfügbaren A-Eintrag. Dieses Tutorial verwendet in allen Bereichen your_domain. Sie können einen Domänennamen unter Namecheap günstig erwerben oder einen kostenlosen von Freenom herunterladen oder einfach die Domänenregistrierungsstelle Ihrer Wahl verwenden. Sie müssen sich erst einmal keine Gedanken um eine Verknüpfung des A-Eintrags Ihrer Domäne mit einer IP-Adresse machen. Sobald Sie Schritt 5 erreichen und Ihr Ingress Controller verfügbar ist, werden Sie your_domain mit der richtigen IP-Adresse verbinden.

      Schritt 1 — Erstellen einer neuen Laravel-Anwendung

      In diesem Schritt verwenden Sie Docker, um eine neue Laravel-7-Anwendung zu erstellen. Sie sollten jedoch mit einer bestehenden Laravel-Anwendung, die MySQL als Backing-Datenbank nutzt, das gleiche Verfahren nutzen können. Die neu erstellte Anwendung wird überprüfen, ob Laravel mit der Datenbank verbunden ist, und den Namen der Datenbank anzeigen.

      Wechseln Sie zunächst in Ihr Stammverzeichnis und erstellen Sie dann eine neue Laravel-Anwendung mit einem Docker-Container vom Typ composer:

      • cd ~
      • docker run --rm -v $(pwd):/app composer create-project --prefer-dist laravel/laravel laravel-kubernetes

      Nach der Fertigstellung des Containers und der Installation aller Composer-Pakete sollten Sie eine neue Installation von Laravel in Ihrem aktuellen Verzeichnis namens laravel-kubernetes/ sehen. Navigieren Sie zu diesem Ordner:

      Von hier führen Sie die restlichen Befehle dieses Tutorials aus.

      Zweck dieser Anwendung ist es, Ihre Datenbankverbindung zu testen und den Namen der Datenbank in Ihrem Browser anzuzeigen. Öffnen Sie die Datei ./resources/views/welcome.blade.php in einem Texteditor, um die Datenbankverbindung zu testen:

      • nano ./resources/views/welcome.blade.php

      Suchen Sie nach dem Abschnitt <div class="links">...</div> und ersetzen Sie den Inhalt durch Folgendes:

      ./resources/views/welcome.blade.php

      ...
      <div class="links">
         <strong>Database Connected: </strong>
          @php
              try {
                  DB::connection()->getPDO();
                  echo DB::connection()->getDatabaseName();
                  } catch (Exception $e) {
                  echo 'None';
              }
          @endphp
      </div>
      ...
      

      Speichern und schließen Sie die Datei.

      Weitere Anpassungen müssen Sie in diesem Tutorial an der standardmäßigen Laravel-Anwendung nicht vornehmen. Nun wird dieser kurze PHP-Abschnitt Ihre Datenbankverbindung testen und den Namen der Datenbank im Laravel-Begrüßungsbildschirm in Ihrem Webbrowser anzeigen.

      Im nächsten Schritt verwenden Sie Docker, um ein Image zu erstellen, das diese Laravel-Anwendung und Docker Compose enthält, um zu testen, ob sie lokal ausgeführt wird und eine Verbindung zu einer MySQL-Datenbank hergestellt wird.

      Schritt 2 — Containerisieren Ihrer Laravel-Anwendung

      Nachdem Sie eine neue Laravel-Anwendung erzeugt haben, müssen Sie nun Ihren Code in ein Docker-Image integrieren und das Image dann mit Docker Compose testen. Zwar ist das Ziel dieses Tutorials, Ihre Anwendung in einem Kubernetes-Cluster bereitzustellen, doch ist Docker Compose eine praktische Option, um Ihr Docker-Image und Ihre Konfiguration vor Ort zu testen, bevor Sie sie in der Cloud ausführen. Die schnelle Feedbackschleife kann nützlich sein, um kleine Änderungen vorzunehmen und zu testen.

      Erstellen Sie zunächst mit nano oder Ihrem bevorzugten Texteditor im Stammverzeichnis Ihrer Laravel-Anwendung eine Datei namens Dockerfile:

      Fügen Sie folgenden Inhalt hinzu: Docker wird diese Datei verwenden, um Ihren Code in ein Image zu integrieren:

      ./Dockerfile

      FROM php:7.4-apache
      
      # Install packages
      RUN apt-get update && apt-get install -y 
          git 
          zip 
          curl 
          sudo 
          unzip 
          libicu-dev 
          libbz2-dev 
          libpng-dev 
          libjpeg-dev 
          libmcrypt-dev 
          libreadline-dev 
          libfreetype6-dev 
          g++
      
      # Apache configuration
      ENV APACHE_DOCUMENT_ROOT=/var/www/html/public
      RUN sed -ri -e 's!/var/www/html!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/sites-available/*.conf
      RUN sed -ri -e 's!/var/www/!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/apache2.conf /etc/apache2/conf-available/*.conf
      RUN a2enmod rewrite headers
      
      # Common PHP Extensions
      RUN docker-php-ext-install 
          bz2 
          intl 
          iconv 
          bcmath 
          opcache 
          calendar 
          pdo_mysql
      
      # Ensure PHP logs are captured by the container
      ENV LOG_CHANNEL=stderr
      
      # Set a volume mount point for your code
      VOLUME /var/www/html
      
      # Copy code and run composer
      COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
      COPY . /var/www/tmp
      RUN cd /var/www/tmp && composer install --no-dev
      
      # Ensure the entrypoint file can be run
      RUN chmod +x /var/www/tmp/docker-entrypoint.sh
      ENTRYPOINT ["/var/www/tmp/docker-entrypoint.sh"]
      
      # The default apache run command
      CMD ["apache2-foreground"]
      

      Speichern und schließen Sie die Datei.

      Diese Dockerfile-Datei startet mit dem in Docker Hub gefundenen PHP 7.4 Apache Docker-Image und installiert dann mehrere Linux-Pakete, die allgemein von Laravel-Anwendungen benötigt werden. Als Nächstes erstellt sie Apache-Konfigurationsdateien und ermöglicht das Umschreiben von Headern. Die Dockerfile-Datei installiert mehrere gängige PHP-Erweiterungen und fügt eine Umgebungsvariable hinzu, um sicherzustellen, dass die Protokolle von Laravel über stderr an den Container gestreamt werden. So können Sie Laravel-Protokolle sehen, indem Sie Ihre Docker Compose- oder Kubernetes-Protokolle durchsehen.

      Schließlich kopiert die Dockerfile-Datei den gesamten Code in Ihrer Laravel-Anwendung nach /var/www/tmp und installiert die Abhängigkeiten von Composer. Dann setzt sie einen ENTRYPOINT. Sie müssen diese Datei aber noch erstellen, was wir als Nächstes tun werden.

      Erstellen Sie im Stammverzeichnis Ihres Projekts eine neue Datei namens docker-entrypoint.sh. Diese Datei wird ausgeführt, wenn Ihr Container lokal oder im Kubernetes Cluster ausgeführt wird. Außerdem wird Ihr Laravel-Anwendungscode vom Verzeichnis /var/www/tmp in /var/www/html kopiert, wo Apache ihn bereitstellen kann.

      • nano ./docker-entrypoint.sh

      Fügen Sie nun folgendes Skript hinzu:

      ./docker-entrypoint.sh

      #!/bin/bash
      
      cp -R /var/www/tmp/. /var/www/html/
      chown -R www-data:www-data /var/www/html
      
      exec "$@"
      

      Die abschließende Zeile exec "$@" weist das Shell an, jeden Befehl auszuführen, der als Nächstes als Eingabeargumenttext übergeben wurde. Dies ist wichtig, da Docker nach Ausführung dieses Skripts den Apache run-Befehl (apache2-foreground) weiter ausführen soll. Speichern und schließen Sie die Datei.

      Erstellen Sie als Nächstes im Stammverzeichnis Ihrer Anwendung eine Datei namens .dockerignore. Diese Datei sorgt dafür, dass Ihr Docker-Image beim Erstellen nicht mit Paketen oder Umgebungsdateien verschmutzt wird, die nicht hinein kopiert werden sollen:

      ./.dockerignore

      .env
      /vendor
      

      Speichern und schließen Sie die Datei.

      Die letzte Datei, die Sie erstellen müssen, bevor Sie Ihre Anwendung mit Docker Compose lokal ausführen können, ist eine docker-compose.yml-Datei. Bei der Konfiguration dieser YAML-Datei müssen Sie jedoch den APP_KEY eingeben, den Laravel bei der Installation generiert hat. Um ihn zu finden, öffnen und durchsuchen Sie die Datei . /.env oder führen die Sie die folgenden Befehle cat und grep aus:

      Sie werden eine Ausgabe wie diese sehen:

      Output

      APP_KEY=base64:0EHhVpgg ... UjGE=

      Kopieren Sie Ihren Schlüssel in die Zwischenablage. Vergewissern Sie sich, dass Sie das Präfix base64: einschließen. Erstellen Sie nun im Stammverzeichnis Ihrer Anwendung die Datei namens docker-compose.yml:

      • nano ./docker-compose.yml

      Hier werden wir das PHP-Image Ihrer Laravel-Anwendung sowie einen MySQL-Container für die Ausführung Ihrer Datenbank einschließen. Fügen Sie den folgenden Inhalt hinzu:

      ./docker-compose.yml

      version: '3.5'
      services:
        php:
          image: your_docker_hub_username/laravel-kubernetes:latest
          restart: always
          ports:
            - 8000:80
          environment:
            - APP_KEY="your_laravel_app_key"
            - APP_ENV=local
            - APP_DEBUG=true
            - DB_PORT=3306
            - DB_HOST=mysql
            - DB_DATABASE
            - DB_USERNAME
            - DB_PASSWORD
        mysql:
          image: mysql:5.7
          restart: always
          environment:
            - MYSQL_ROOT_PASSWORD=${DB_ROOT_PASSWORD}
            - MYSQL_DATABASE=${DB_DATABASE}
            - MYSQL_USER=${DB_USERNAME}
            - MYSQL_PASSWORD=${DB_PASSWORD}
      

      Verwenden Sie die Variable APP_KEY, die Sie in Ihre Zwischenablage kopiert haben, für die Variable <^>your_laravel_app_key und Ihren Docker Hub-Benutzernamen für die Variable your_docker_hub_username<^>. Speichern und schließen Sie die Datei.

      Sie werden das erste Image lokal mit docker build erstellen. Das zweite Image ist das offizielle MySQL Docker-Image, das in Docker Hub verfügbar ist. Beide benötigen verschiedene Umgebungsvariablen, die Sie bei Ausführung der Container einschließen werden.

      Um das Docker-Image mit Ihrer Laravel-Anwendung zu erstellen, führen Sie folgenden Befehl aus. Ersetzen Sie your_docker_hub_username durch Ihren Benutzernamen oder den Benutzernamen Ihres Teams bei Docker Hub, wo dieses Image gespeichert werden soll:

      • docker build -t your_docker_hub_username/laravel-kubernetes:latest .

      Als Nächstes können Sie die beiden Container unter Verwendung von Docker Compose mit den erforderlichen Datenbankanmeldedaten ausführen:

      • DB_ROOT_PASSWORD=rootpassword DB_DATABASE=local_db DB_USERNAME=admin DB_PASSWORD=password docker-compose up -d

      Die hier verwendeten vier Umgebungsvariablen (DB_ROOT_PASSWORD, DB_DATABASE, DB_USERNAME, DB_PASSWORD) können bei Bedarf geändert werden; da Sie Ihre Anwendung jedoch nur vor Ort testen, müssen Sie sich noch nicht um ihre Sicherheit kümmern.

      Es kann bis zu 30 Sekunden dauern, bis Ihre MySQL-Datenbank initialisiert ist und die Container einsatzbereit sind. Sobald das der Fall ist, können Sie Ihre Laravel-Anwendung auf Ihrem Computer unter localhost:8000 anzeigen.

      Die Laravel-Anwendung, die mit Docker Compose lokal ausgeführt wird

      Ihre PHP-Anwendung wird sich mit Ihrer MySQL-Datenbank verbinden. Nach erfolgreicher Verbindungsherstellung wird unter dem Laravel-Logo der Text „Database Connected: localdb“ (Datenbank verbunden: localdb) angezeigt.

      Nachdem Sie Ihr Docker-Image mit Docker Compose lokal getestet haben, können Sie die Container mit docker-compose down nun herunterfahren:

      Im nächsten Abschnitt pushen Sie Ihr Docker-Image an Docker Hub, damit es Ihr Helm Chart nutzen kann, um die Anwendung in Ihrem Kubernetes-Cluster bereitzustellen.

      Schritt 3 — Pushen Ihres Docker-Image an Docker Hub

      Das LAMP Helm Chart, das Sie zur Bereitstellung Ihres Codes an Kubernetes verwenden werden, erfordert, dass Ihr Code in einer Container-Registry verfügbar ist. Zwar können Sie Ihr Image in eine private oder selbst gehostete Registry pushen, doch verwenden Sie in diesem Tutorial eine öffentlich verfügbare und kostenlose Docker-Registry in Docker Hub.

      Greifen Sie mit Ihrem Webbrowser auf Ihr Konto in Docker Hub zu und erstellen Sie dann ein neues Repository namens laravel-kubernetes.

      Erstellen eines neuen Repository in Docker Hub

      Wenn Sie von Ihrem lokalen Computer noch keine Verbindung zu Docker Hub hergestellt haben, müssen Sie sich bei Docker Hub anmelden. Sie können dies über die Befehlszeile tun:

      • docker login -u your_docker_hub_username

      Geben Sie Ihre Anmeldedaten ein, wenn Sie dazu aufgefordert werden. Dies muss normalerweise nur einmal pro Computer erfolgen, da Docker Ihre Anmeldedaten in Ihrem Stammverzeichnis in ~/.docker/config.json speichert.

      Abschließend pushen Sie Ihr Image an Docker Hub:

      • docker push your_docker_hub_username/laravel-kubernetes:latest

      Je nach Verbindungsgeschwindigkeit kann es einige Minuten dauern, bis Ihre Anwendung hochgeladen ist. Sobald Docker fertig ist, sehen Sie ein endgültiges Digest-Hash und die Größe Ihres Images im Terminal. Dies sollte ungefähr so aussehen:

      Output

      latest: digest: sha256:df4bdeda91484c8c26a989b13b8f27ab14d93ab2e676e3c396714cb3811c4086 size: 4918

      Nachdem Sie Ihre Laravel-Anwendung containerisiert und ein Image an Docker Hub gepusht haben, können Sie das Image nun in einer Helm Chart- oder Kubernetes-Bereitstellung verwenden. Im nächsten Schritt werden Sie basierend auf dem LAMP Helm Chart benutzerdefinierte Werte festlegen und die Anwendung in Ihrem DigitalOcean Kubernetes-Cluster bereitstellen.

      Schritt 4 — Konfigurieren und Bereitstellen der Anwendung mit dem LAMP Helm Chart

      Helm bietet eine Reihe von Charts, um Ihnen mit voreingestellten Kombinationen von Tools bei der Einrichtung von Kubernetes-Anwendungen zu helfen. Sie können zwar eigene Kubernetes-Dienstdateien schreiben, um eine eine ähnliche Bereitstellung zu erhalten, doch werden Sie in diesem Bereich sehen, warum die Verwendung eines Helm Chart die Konfiguration deutlich erleichtert.

      Zuerst benötigen Sie ein Verzeichnis, in dem alle Ihre Helm-Konfigurationsdateien gespeichert werden. Erstellen Sie im Stammverzeichnis Ihres Laravel-Projekts ein neues Verzeichnis namens helm/:

      Im Verzeichnis helm/ werden Sie zwei neue Dateien erstellen: values.yml und secrets.yml. Erstellen und öffnen Sie zunächst values.yml:

      Die Datei values.yml enthält nicht-geheime Konfigurationsoptionen, die die Standardwerte im LAMP Helm Chart überschreiben werden. Fügen Sie folgende Konfigurationen hinzu und stellen Sie sicher, your_docker_hub_username durch Ihren eigenen Benutzernamen zu ersetzen:

      ./helm/values.yml

      php:
        repository: "your_docker_hub_username/laravel-kubernetes"
        tag: "latest"
        fpmEnabled: false
        envVars:
          - name: APP_ENV
            value: production
          - name: APP_DEBUG
            value: false
          - name: DB_PORT
            value: 3306
          - name: DB_HOST
            value: localhost
      

      Speichern und schließen Sie die Datei.

      Erstellen Sie nun eine Datei namens secrets.yml:

      secrets.yml wird nicht in der Versionskontrolle geprüft. Sie enthält sensible Konfigurationsdaten wie Ihr Datenbankpasswort und den Laravel-App Key. Fügen Sie die folgenden Konfigurationen hinzu und nehmen Sie gegebenenfalls Anpassungen für Ihre Anmeldedaten vor:

      ./helm/secrets.yml

      mysql:
        rootPassword: "your_database_root_password"
        user: your_database_user
        password: "your_database_password"
        database: your_database_name
      
      php:
        envVars:
          - name: APP_KEY
            value: "your_laravel_app_key"
          - name: DB_DATABASE
            value: your_database_name
          - name: DB_USERNAME
            value: your_database_user
          - name: DB_PASSWORD
            value: "your_database_password"
      

      Verwenden Sie für Ihre Produktionsdatenbank starke Benutzername- und Passwortkombinationen und nutzen Sie den gleichen your_laravel_app_key wie oben; öffnen Sie alternativ ein neues Terminalfenster und generieren Sie einen neuen App Key, indem Sie folgenden Befehl ausführen. Dann können Sie den neuen Wert, den Laravel festlegt, in Ihre .env-Datei kopieren:

      • docker run --rm -v $(pwd):/app php:cli php /app/artisan key:generate

      Speichern und schließen Sie secrets.yml.

      Um zu verhindern, dass Ihre secrets.yml-Datei in das Docker-Image integriert oder in der Versionskontrolle gespeichert wird, sollten Sie als Nächstes sowohl der Datei .dockerignore als auch der Datei .gitignore die folgende Zeile hinzufügen. Öffnen und fügen Sie jeder Datei /helm/secrets.yml an oder führen Sie den folgenden Befehl aus, um beide hinzuzufügen:

      • echo '/helm/secrets.yml' >> ./.dockerignore && echo '/helm/secrets.yml' >> ./.gitignore

      Nachdem Sie Helm-Konfigurationsdateien für Ihre Anwendung und das Docker-Image erstellt haben, können Sie dieses Helm Chart nun als neue Version in Ihrem Kubernetes-Cluster installieren. Installieren Sie Ihr Chart im Stammverzeichnis Ihrer Anwendung:

      • helm install laravel-kubernetes -f helm/values.yml -f helm/secrets.yml stable/lamp

      Sie werden eine Ausgabe wie diese sehen:

      Output

      NAME: laravel-kubernetes LAST DEPLOYED: Mon May 18 13:21:20 2020 NAMESPACE: default STATUS: deployed REVISION: 1

      Ihre Anwendung wird eine oder zwei Minuten brauchen, bis sie verfügbar ist. Sie können jedoch folgenden Befehl ausführen, um die Kubernetes-Dienste in Ihrem Cluster zu überwachen:

      Suchen Sie nach dem Namen Ihrer Anwendung:

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) laravel-kubernetes-lamp LoadBalancer your_cluster_ip your_external_ip 80:32175/TCP,3306:32243/TCP

      Wenn Ihr neuer Dienst laravel-kubernetes-lamp unter EXTERNAL-IP eine IP-Adresse anzeigt, können Sie your_external_ip aufrufen, um die in Ihrem Kubernetes-Cluster ausgeführte Anwendung anzuzeigen. Ihre Anwendung wird sich mit Ihrer Datenbank verbinden und Sie werden den Namen der Datenbank unterhalb des Laravel-Logos sehen (genauso wie bei der lokalen Ausführung Ihrer Anwendung in Docker Compose).

      Die Laravel-Anwendung, die in Kubernetes mit dem LAMP Helm Chart ausgeführt wird

      Das Ausführen einer Webanwendung an einer ungesicherten IP-Adresse kann für einen Konzeptnachweis in Ordnung sein, Ihre Website ist jedoch ohne SSL-Zertifikat und einen benutzerdefinierten Domänennamen nicht bereit für die Produktion. Bevor Sie dies im nächsten Schritt einrichten, deinstallieren Sie Ihre Version über die Befehlszeile:

      • helm delete laravel-kubernetes

      Im nächsten Schritt werden Sie auf Grundlage dieser ersten Helm-Konfiguration Ihrer Laravel-Anwendung einen Ingress Controller, ein SSL-Zertifikat und eine benutzerdefinierte Domäne hinzuzufügen.

      Schritt 5 — Hinzufügen von Ingress Controller und SSL zu Ihrem Kubernetes Cluster

      Ein Ingress Controller ist in Kubernetes dafür verantwortlich, die Dienste Ihrer Anwendung im Internet zu verfügbar zu machen. Im vorherigen Schritt hat das LAMP Helm Chart einen DigitalOcean Load Balancer erstellt und Ihre Anwendung direkt über die IP-Adresse des Load Balancer verfügbar gemacht.

      Sie könnten SSL und Ihren Domänennamen direkt im Load Balancer terminieren; da Sie jedoch in Kubernetes arbeiten, kann es praktischer sein, alles an einem Ort zu verwalten. Deutlich ausführlichere Informationen zu Ingress Controllern und Details zu den folgenden Schritten finden Sie unter Verwenden eines Nginx Ingress in DigitalOcean Kubernetes mit Helm.

      Das LAMP Helm Chart enthält eine Konfigurationsoption zur Unterstützung von Ingress. Öffnen Sie die Datei helm/values.yml:

      Fügen Sie jetzt die folgenden Zeilen hinzu:

      ./helm/values.yml

      ...
      # Use Ingress Controller
      service:
        type: ClusterIP
        HTTPPort: 80
      ingress:
        enabled: true
        domain: your_domain
      

      Dadurch wird Ihre Bereitstellung angewiesen, keinen Load Balancer zu installieren und die Anwendung stattdessen an Port 80 des Kubernetes-Clusters verfügbar zu machen, wo der Ingress Controller sie im Internet verfügbar macht. Speichern und schließen Sie values.yml.

      Führen Sie nun den Befehl helm install aus, den Sie zuvor ausgeführt haben, damit Ihre Laravel-Anwendung wieder ausgeführt wird. Stellen Sie sicher, dass Sie den Befehl aus dem Stammverzeichnis Ihrer Anwendung ausführen:

      • helm install laravel-kubernetes -f helm/values.yml -f helm/secrets.yml stable/lamp

      Installieren Sie als Nächstes den Controller nginx-ingress in Ihrem Kubernetes-Cluster mit dem von Kubernetes verwalteten Nginx Ingress Controller:

      • helm install nginx-ingress stable/nginx-ingress --set controller.publishService.enabled=true

      Nach der Installation werden Sie eine Ausgabe wie diese sehen:

      Output

      NAME: nginx-ingress LAST DEPLOYED: Mon May 18 13:28:34 2020 NAMESPACE: default STATUS: deployed REVISION: 1

      Außerdem benötigen Sie eine Ingress-Ressource, um die Bereitstellung Ihrer Laravel-Anwendung verfügbar zu machen. Erstellen Sie im Stammverzeichnis Ihrer Anwendung eine neue Datei namens ingress.yml:

      Diese Datei legt den Host, den SSL-Zertifikatmanager und den Backend-Dienst und Port-Namen der Anwendung fest. Fügen Sie die folgenden Konfigurationen hinzu, wobei Sie your_domain durch die Domäne Ihrer Wahl ersetzen:

      ./ingress.yml

      apiVersion: networking.k8s.io/v1beta1
      kind: Ingress
      metadata:
        name: laravel-kubernetes-ingress
        annotations:
          kubernetes.io/ingress.class: nginx
          cert-manager.io/cluster-issuer: letsencrypt-prod
      spec:
        tls:
          - hosts:
              - your_domain
            secretName: laravel-kubernetes-tls
        rules:
          - host: your_domain
            http:
              paths:
                - backend:
                    serviceName: laravel-kubernetes-lamp
                    servicePort: 80
      

      Speichern und schließen Sie die Datei.

      Als Nächstes sollten Sie Cert-Manager installieren und einen Aussteller erstellen, mit dem Sie mit Let’s Encrypt SSL-Zertifikate für die Produktion erzeugen können. Cert-Manager erfordert benutzerdefinierte Ressourcendefinitionen, die Sie aus dem Cert-Manager-Repository über die Befehlszeile anwenden können:

      • kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v0.15.0/cert-manager.crds.yaml

      Dadurch wird eine Reihe von Kubernetes-Ressourcen erstellt, die in der Befehlszeile angezeigt werden:

      Output

      customresourcedefinition.apiextensions.k8s.io/certificaterequests.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/certificates.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/challenges.acme.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/clusterissuers.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/issuers.cert-manager.io created customresourcedefinition.apiextensions.k8s.io/orders.acme.cert-manager.io create

      Außerdem benötigt Cert-Manager einen Namespace zur Isolation in Ihrem Kubernetes-Cluster:

      • kubectl create namespace cert-manager

      Sie sehen diese Ausgabe:

      Output

      namespace/cert-manager created

      Da Cert-Manager von Jetstack keines der von Kubernetes verwalteten Charts ist, müssen Sie auch das Jetstack Helm-Repository hinzufügen. Führen Sie folgenden Befehl aus, um es in Helm verfügbar zu machen:

      • helm repo add jetstack https://charts.jetstack.io

      Bei erfolgreicher Ergänzung erhalten Sie folgende Ausgabe:

      Output

      "jetstack" has been added to your repositories

      Jetzt können Sie Cert-Manager in Ihrem Kubernetes-Cluster im Namespace cert-manager installieren:

      • helm install cert-manager --version v0.15.0 --namespace cert-manager jetstack/cert-manager

      Nach Abschluss sehen Sie eine Zusammenfassung der Bereitstellung, die in etwa wie folgt aussieht:

      Output

      NAME: cert-manager LAST DEPLOYED: Mon May 18 13:32:08 2020 NAMESPACE: cert-manager STATUS: deployed REVISION: 1

      Die letzte Datei, die Sie dem Stammverzeichnis Ihrer Laravel-Anwendung hinzufügen müssen, ist eine Kubernetes-Konfigurationsdatei namens production_issuer.yml. Erstellen Sie die Datei:

      • nano ./production_issuer.yml

      Fügen Sie nun Folgendes hinzu:

      apiVersion: cert-manager.io/v1alpha2
      kind: ClusterIssuer
      metadata:
        name: letsencrypt-prod
      spec:
        acme:
          # Email address used for ACME registration
          email: your_email_address
          server: https://acme-v02.api.letsencrypt.org/directory
          privateKeySecretRef:
            # Name of a secret used to store the ACME account private key
            name: letsencrypt-prod-private-key
          # Add a single challenge solver, HTTP01 using nginx
          solvers:
            - http01:
                ingress:
                  class: nginx
      

      Speichern und schließen Sie die Datei.

      Let’s Encrypt sendet an your_email_address sämtliche wichtigen Hinweise und Warnungen zum Ablauf von Zertifikaten; darum sollten Sie eine Adresse hinzufügen, die Sie regelmäßig prüfen. Speichern Sie diese Datei und erstellen Sie eine neue Ressource sowohl für Ihre Ingress-Ressource als auch den Produktionsaussteller in Ihrem Kubernetes-Cluster:

      • kubectl create -f ingress.yml
      • kubectl create -f production_issuer.yml

      Aktualisieren Sie schließlich die DNS-Einträge Ihres Domänennamens so, dass ein A-Eintrag auf die IP-Adresse Ihres Load Balancer verweist. Um nach der IP-Adresse Ihres Ingress Controller zu suchen, geben Sie Folgendes ein:

      • kubectl get service nginx-ingress-controller

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE nginx-ingress-controller LoadBalancer your_cluster_ip your_external_ip 80:30187/TCP,443:31468/TCP 6m10s

      Verwenden Sie die Adresse your_external_ip als IP-Adresse für Ihren DNS A-Eintrag. Das Verfahren zur Aktualisierung Ihrer DNS-Einträge variiert, je nachdem wo Sie Ihre Domänennamen und das DNS-Hosting verwalten. Wenn Sie DigitalOcean verwenden, können Sie jedoch unseren Leitfaden zum Verwalten von DNS-Einträgen konsultieren.

      Sobald Ihre DNS-Einträge aktualisiert und das SSL-Zertifikat generiert wurden, wird Ihre Anwendung in your_domain verfügbar und SSL aktiviert.

      Die Laravel-Anwendung mit SSL-Terminierung und einem benutzerdefinierten Domänennamen

      Zwar sind Ihre PHP-Anwendung und Ihre Datenbank bereits miteinander verbunden, doch müssen Sie noch Datenbankmigrationen ausführen. Im letzten Schritt erfahren Sie, wie Sie Artisan-Befehle in Ihrem Kubernetes-Pod ausführen können, um Datenbankmigrationen und andere häufige Wartungsaufgaben durchzuführen.

      Schritt 6 — Ausführen von Remotebefehlen

      Zwar wird Ihre Laravel-Anwendung ausgeführt und ist mit der MySQL-Datenbank in Kubernetes verbunden, doch gibt es mehrere gängige Aufgaben, die Sie in einer neuen Laravel-Installation erledigen sollten. Eine gängige Aufgabe, die Sie ausführen sollten, sind Datenbankmigrationen.

      Bevor Sie in Ihrer Laravel-Anwendung einen Artisan-Befehl ausführen können, müssen Sie den Namen des Pods kennen, das Ihren Laravel-Anwendungscontainer ausführt. Mit der Befehlszeile können Sie alle Pods in Ihrem Kubernetes-Cluster anzeigen:

      Sie werden eine Ausgabe wie diese sehen:

      Output

      NAME READY STATUS RESTARTS AGE laravel-kubernetes-lamp-77fb989b46-wczgb 2/2 Running 0 16m

      Wählen Sie das Pod für Ihre laravel-kubernetes-lamp-...-Bereitstellung aus. Stellen Sie sicher, dass Sie den Namen in Ihrer Ausgabe verwenden und nicht den oben aufgeführten Namen. Jetzt können Sie kubectl exec dafür ausführen. Beispielsweise führen Sie eine Datenbankmigration mit dem Befehl artisan migrate aus. Sie fügen das Flag --force hinzu, da Sie das Pod in der Produktion ausführen:

      • kubectl exec laravel-kubernetes-lamp-77fb989b46-wczgb -- php artisan migrate --force

      Dieser Befehl wird eine Ausgabe erzeugen:

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.16 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.05 seconds)

      Sie haben Laravel 7 und MySQL nun erfolgreich in Kubernetes bereitgestellt und eine wichtige Aufgabe zur Datenbankwartung durchgeführt.

      Zusammenfassung

      In diesem Tutorial haben Sie gelernt, wie Sie eine Laravel PHP-Anwendung containerisieren, mit einer MySQL-Datenbank verbinden, ein Docker-Image mit Ihrem Code an Docker Hub pushen und dann ein Helm Chart nutzen, um das Image in einem DigitalOcean Kubernetes-Cluster bereitzustellen. Schließlich haben Sie SSL und einen benutzerdefinierten Domänennamen hinzugefügt und erfahren, wie Sie in Ihren laufenden Pods Befehlszeilentools ausführen.

      Kubernetes and Helm bieten Ihnen eine Reihe von Vorteilen gegenüber dem herkömmlichen LAMP-Stack-Hosting: Skalierbarkeit, die Fähigkeit, Dienste ohne direkte Anmeldung bei Ihrem Server auszutauschen, Tools zur Durchführung von rollierenden Upgrades und Kontrolle über Ihre Hostingumgebung. Es muss jedoch gesagt werden, dass die Komplexität der anfänglichen Containerisierung und Konfiguration Ihrer Anwendung am Anfang eine relativ hohe Barriere darstellt. Mit diesem Leitfaden als Ausgangspunkt wird die Bereitstellung von Laravel in Kubernetes jedoch verständlicher. Vielleicht wollen Sie nun mehr über die Vorzüge von Laravel oder das Hinzufügen von Überwachungstools (wie Linkerd) zu Kubernetes zu erfahren (manuell installierbar mit unserem Leitfaden oder mit einem DigitalOcean 1-Click).



      Source link

      Installieren und Konfigurieren von Postfix unter Ubuntu 20.04


      Eine frühere Version dieses Tutorials wurde von Justin Ellingwood verfasst

      Einführung

      Postfix ist ein beliebter Open-Source Mail Transfer Agent (MTA), der zur Weiterleitung und Zustellung von E-Mails auf einem Linux-System verwendet werden kann. Schätzungen zufolge führen etwa 25 % der öffentlichen Mail-Server im Internet Postfix aus.

      In diesem Leitfaden zeigen wir Ihnen, wie Sie Postfix auf einem Ubuntu 20.04 Server installieren und konfigurieren. Anschließend testen Sie, ob Postfix in der Lage ist, E-Mails korrekt weiterzuleiten, indem Sie s-nail, einen Mail User Agent (MUA), auch als E-Mail-Client bekannt, installieren.

      Beachten Sie, dass das Ziel dieses Tutorials darin besteht, Ihnen dabei zu helfen, Postfix schnell zum Laufen zu bringen, und zwar mit nur einigen grundlegenden E-Mail-Funktionen. Am Ende dieses Leitfadens werden Sie zwar noch nicht über einen voll funktionsfähigen E-Mail-Server verfügen, aber einige der grundlegenden Komponenten einer solchen Einrichtung werden Ihnen den Einstieg erleichtern.

      Voraussetzungen

      Um diesem Leitfaden zu folgen, benötigen Sie Folgendes:

      • Einen Server mit Ubuntu 20.04, der als Postfix Mail-Server fungiert. Dieser Server sollte über einen Nicht-root-Benutzer mit sudo-Berechtigungen und eine mit UFW konfigurierte Firewall verfügen. Um das einzurichten, können Sie unserem Leitfaden zur Ersteinrichtung des Servers unter Ubuntu 20.04 folgen.
      • Einen vollständig qualifizierten Domänennamen, der auf Ihren Ubuntu 20.04-Server verweist. Hilfe bei der Einrichtung Ihres Domänennamens mit DigitalOcean finden Sie, indem Sie unserer Dokumentation Domänen und DNS-Netzwerke folgen. Beachten Sie, dass Sie, wenn Sie den Zugriff auf E-Mails von einem externen Standort planen, sicherstellen müssen, dass Sie auch über einen MX-Datensatz verfügen, der auf auf Ihren Mail-Server verweist.

      Beachten Sie, dass dieses Tutorial davon ausgeht, dass Sie einen Host konfigurieren, der den FQDN von mail.example.com hat. Falls erforderlich, stellen Sie sicher, dass Sie example.com oder mail.example.com so ändern, dass sie Ihren eigenen FQDN widerspiegeln.

      Schritt 1 — Installieren von Postfix

      Postfix ist in den Standard-Repositorys von Ubuntu enthalten, sodass Sie es mit APT installieren können.

      Um zu beginnen, aktualisieren Sie Ihren lokalen apt-Paketcache:

      Installieren Sie dann das Paket postfix mit dem folgenden Beachten Sie, dass wir hier die Umgebungssvariable DEBIAN_PRIORITY=low an diesen Installationsbefehl übergeben. Dies führt dazu, dass der Installationsprozess Sie auffordert, einige zusätzliche Optionen zu konfigurieren:

      • sudo DEBIAN_PRIORITY=low apt install postfix

      Dieser Installationsprozess öffnet eine Reihe von interaktiven Eingabeaufforderungen. Verwenden Sie für die Zwecke dieses Tutorials die folgenden Informationen, um Ihre Eingabeaufforderungen auszufüllen:

      • General type of mail configuration? Wählen Sie hierfür Internet Site, da dies unseren Infrastrukturanforderungen entspricht.
      • System mail name: Dies ist die Basisdomäne, die zur Erstellung einer gültigen E-Mail-Adresse verwendet wird, wenn nur der Kontoteil der Adresse angegeben wird. Nehmen wir beispielsweise an, dass der Hostname Ihres Servers mail.example.com lautet. Wahrscheinlich möchten Sie den System-Mail-Namen auf example.com setzen, sodass Postfix bei der Angabe des Benutzernamens user1 die Adresse user1@example.com verwendet.
      • Root and postmaster mail recipient: Dies ist das Linux-Konto, das an root@ und postmaster@ adressierte Mail weitergeleitet wird. Verwenden Sie hierfür Ihr primäres Konto. In diesem Beispielfall sammy.
      • Other destinations to accept mail for: Dies definiert die E-Mail-Ziele, die diese Postfix-Instanz akzeptiert. Wenn Sie weitere Domänen hinzufügen müssen, für deren Empfang dieser Server verantwortlich ist, fügen Sie diese hier hinzu. Andernfalls ist die Standardeinstellung ausreichend.
      • Force synchronous updates on mail queue?: Da Sie wahrscheinlich ein journalisiertes Dateisystem verwenden, akzeptieren Sie hier No.
      • Local networks: Dies ist eine Liste der Netzwerke, für die Ihr Mail-Server für die Weiterleitung von Nachrichten konfiguriert ist. Die Standardeinstellung wird für die meisten Szenarien funktionieren. Wenn Sie sie jedoch modifizieren möchten, stellen Sie sicher, dass Sie in Bezug auf den Netzwerkbereich sehr restriktiv sind.
      • Mailbox size limit: Dies kann verwendet werden, um die Größe von Nachrichten zu begrenzen. Eine Einstellung auf 0 deaktiviert jede Größenbeschränkung.
      • Local address extension character: Dies ist as Zeichen, das verwendet werden kann, um den regulären Teil der Adresse von einer Erweiterung zu trennen (verwendet zur Erstellung dynamischer Aliase) Die Standardeinstellung + funktioniert für dieses Tutorial.
      • Internet protocols to use: Wählen Sie, ob die IP-Version, die Postfix unterstützt, eingeschränkt werden soll. Wählen Sie für die Zwecke dieses Tutorials all aus.

      Um genau zu sein, sind dies die in diesem Leitfaden verwendeten Einstellungen:

      • General type of mail configuration?: Internet Site
      • System mail name: example.com (nicht mail.example.com)
      • Root and postmaster mail recipient: Der Benutzername Ihres primären Linux-Kontos (in unserem Beispiel sammy).
      • Other destinations to accept mail for: $myhostname, example.com, mail.example.com, localhost.example.com, localhost
      • Force synchronous updates on mail queue?: No
      • Local networks: 127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128
      • Mailbox size limit: 0
      • Local address extension character: +
      • Internet protocols to use: all

      Anmerkung: Wenn Sie jemals zurückkehren müssen, um diese Einstellungen zu ändern, können Sie dies durch die folgende Eingabe tun:

      • sudo dpkg-reconfigure postfix

      Die Eingabeaufforderungen werden mit Ihren vorherigen Antworten vorausgefüllt.

      Wenn der Installationsprozess abgeschlossen ist, können Sie einige Aktualisierungen an Ihrer Postfix-Konfiguration vornehmen.

      Schritt 2 — Ändern der Postfix-Konfiguration

      Jetzt können Sie einige Einstellungen anpassen, zu denen Sie bei der Paketinstallation nicht aufgefordert wurden. Viele der Konfigurationseinstellungen von Postfix sind in der Datei /etc/postfix/main.cf definiert. Anstatt diese Datei direkt zu bearbeiten, können Sie den Befehl postconf von Postfix verwenden, um Konfigurationseinstellungen abzufragen oder festzulegen.

      Legen Sie zunächst den Speicherort für das Postfach Ihres Nicht-root-Ubuntu-Benutzers fest. In diesem Leitfaden verwenden wir das Format Maildir, das Nachrichten in einzelne Dateien trennt, die dann basierend auf Benutzeraktionen zwischen Verzeichnissen verschoben werden. Die alternative Option, die in diesem Leitfaden nicht abgedeckt ist, ist das mbox-Format, das alle Nachrichten innerhalb einer einzigen Datei speichert.

      Setzen Sie die Variable home_mailbox auf Maildir/. Später erstellen Sie eine Verzeichnisstruktur unter diesem Namen innerhalb des Home-Verzeichnisses Ihres Benutzers. Konfigurieren Sie home_mailbox durch Eingabe von:

      • sudo postconf -e 'home_mailbox= Maildir/'

      Als Nächstes legen Sie den Speicherort für die Tabelle virtual_alias_maps fest, die beliebige E-Mail-Konten an Linux-Systemkonten abbildet. Führen Sie den folgenden Befehl aus, der den Tabellenspeicherort einer Hash-Datenbankdatei namens /etc/postfix/virtual zuordnet:

      • sudo postconf -e 'virtual_alias_maps= hash:/etc/postfix/virtual'

      Nachdem Sie nun den Speicherort der virtuellen Zuordnungsdatei in Ihrer Datei main.cf definiert haben, können Sie die Datei selbst erstellen und mit der Zuordnung von E-Mail-Konten zu Benutzerkonten auf Ihrem Linux-System beginnen. Erstellen Sie die Datei mit Ihrem bevorzugten Texteditor; in diesem Beispiel verwenden wir nano:

      • sudo nano /etc/postfix/virtual

      Listen Sie alle Adressen auf, für die Sie E-Mail akzeptieren möchten, gefolgt von einem Leerzeichen und dem Linux-Benutzer, an den die E-Mail zugestellt werden soll.

      Wenn Sie beispielsweise E-Mails bei contact@example.com und admin@example.com akzeptieren möchten und diese E-Mails an den Linux-Benutzer sammy zugestellt werden sollen, können Sie Ihre Datei wie folgt einrichten:

      /etc/postfix/virtual

      contact@example.com sammy
      admin@example.com sammy
      

      Nachdem Sie alle Adressen den entsprechenden Serverkonten zugeordnet haben, speichern und schließen Sie die Datei. Wenn Sie nano verwendet haben, drücken Sie STRG+X, Y, dann ENTER.

      Wenden Sie die Zuordnung durch die folgende Eingabe an:

      • sudo postmap /etc/postfix/virtual

      Starten Sie den Postfix-Prozess neu, um sicherzustellen, dass alle Ihre Änderungen angewendet wurden:

      • sudo systemctl restart postfix

      Wenn Sie dem Leitfaden zur Ersteinrichtung des Servers gefolgt sind, der als Voraussetzung gilt, haben Sie eine mit UFW konfigurierte Firewall. Diese Firewall blockiert standardmäßig externe Verbindungen zu Diensten auf Ihrem Server, es sei denn, diese Verbindungen werden ausdrücklich zugelassen. Sie müssen daher eine Firewall-Regel hinzufügen, um eine Ausnahme für Postfix zuzulassen.

      Sie können Verbindungen zu dem Dienst zulassen, indem Sie Folgendes eingeben:

      Damit ist Postfix konfiguriert und bereit, externe Verbindungen zu akzeptieren. Sie sind jedoch noch nicht bereit, es mit einem Mail-Client auszutesten. Bevor Sie einen Client installieren und ihn für die Interaktion mit der an Ihren Server zugestellten E-Mail verwenden können, müssen Sie einige Änderungen an der Einrichtung Ihres Ubuntu-Servers vornehmen.

      Schritt 3 — Installieren des Mail-Clients und Initialisieren der Maildir-Struktur

      Um mit der zugestellten Mail zu interagieren, führt Sie dieser Schritt durch den Prozess des Installierens des Pakets s-nail. Dies ist eine funktionsreiche Variante des BSD-xmail-Clients, die das Maildir-Format korrekt verarbeiten kann.

      Vor dem Installieren des Clients wäre es jedoch ratsam, sicherzustellen, dass Ihre Umgebungsvariable MAIL korrekt festgelegt ist. s-nail wird nach dieser Variable suchen, um herauszufinden, wo die Mail für Ihren Benutzer zu finden ist.

      Um sicherzustellen, dass die Variable MAIL unabhängig davon festgelegt ist, wie Sie auf Ihr Konto zugreifen – ob beispielsweise über ssh, su, su- oder sudo – müssen Sie die Variable in der Datei /etc/bash.bashrc festlegen und sie zu einer Datei innerhalb von /etc/bash.bashrc hinzufügen, um sicherzustellen, dass sie standardmäßig für alle Benutzer festgelegt ist.

      Um die Variable zu diesen Dateien hinzuzufügen, geben Sie Folgendes ein:

      • echo 'export MAIL=~/Maildir' | sudo tee -a /etc/bash.bashrc | sudo tee -a /etc/profile.d/mail.sh

      Um die Variable in Ihre aktuelle Sitzung einzulesen, rufen Sie die Datei /etc/profile.d/mail.sh auf:

      • source /etc/profile.d/mail.sh

      Installieren Sie dann den E-Mail-Client s-nail mit APT:

      Bevor Sie den Client ausführen, müssen Sie noch einige Einstellungen vornehmen: Öffnen Sie die Datei /etc/s-nail.rc in Ihrem Editor:

      Fügen Sie am Ende der Datei die folgenden Optionen hinzu:

      /etc/s-nail.rc

      . . .
      set emptystart
      set folder=Maildir
      set record=+sent
      

      Diese Zeilen bewirken Folgendes:

      • set emptystart: ermöglicht das Öffnen des Clients auch mit einem leeren Postfach
      • set folder=Maildir: setzt das Verzeichnis Maildir auf die interne Folder-Variable
      • set record=+sent erzeugt eine mbox-Datei sent zum Speichern gesendeter E-Mails in dem Verzeichnis, das als Variable folder festgelegt ist, in diesem Fall Maildir

      Wenn Sie fertig sind, speichern und schließen Sie die Datei. Sie sind nun bereit, die Maildir-Struktur Ihres Systems zu initialisieren.

      Eine schnelle Möglichkeit, die Maildir-Struktur in Ihrem Home-Verzeichnis zu erstellen, besteht darin, sich selbst mit dem Befehl s-nail eine E-Mail zu senden. Da die Datei sent erst zur Verfügung steht, wenn Maildir erstellt ist, sollten Sie das Schreiben an diese Datei für diese erste E-Mail deaktivieren. Führen Sie dies durch die Übergabe der Option -Snorecord aus.

      Senden Sie die E-Mail, indem Sie einen Zeichenfolge an den Befehl s-nail übergeben. Passen Sie den Befehl so an, dass Ihr Linux-Benutzer als Empfänger markiert wird:

      • echo 'init' | s-nail -s 'init' -Snorecord sammy

      Anmerkung: Sie erhalten möglicherweise die folgende Antwort:

      Output

      Can't canonicalize "/home/sammy/Maildir"

      Dies ist normal und kann nur beim Senden dieser ersten Nachricht erscheinen.

      Sie können überprüfen, ob das Verzeichnis erstellt wurde, indem Sie nach Ihrem Verzeichnis ~/Maildir suchen:

      Sie werden sehen, dass die Verzeichnisstruktur erstellt wurde und dass sich eine neue Nachrichtendatei im Verzeichnis ~/Maildir/new befindet:

      Output

      /home/sammy/Maildir/: cur new tmp /home/sammy/Maildir/cur: /home/sammy/Maildir/new: 1463177269.Vfd01I40e4dM691221.mail.example.com /home/sammy/Maildir/tmp:

      Nachdem die Verzeichnisstruktur nun erstellt wurde, können Sie den s-nail-Client testen, indem Sie die von Ihnen gesendete init-Nachricht anzeigen und eine Nachricht an eine externe E-Mail-Adresse senden.

      Schritt 5 – Testen des Clients

      Führen Sie zum Öffnen des Clients den Befehl s-nail aus:

      In Ihrer Konsole sehen Sie einen rudimentären Posteingang, in dem die init-Nachricht wartet:

      Output

      s-nail version v14.9.15. Type `?' for help "/home/sammy/Maildir": 1 message 1 new >N 1 sammy@example.com 2020-05-19 15:40 14/392 init

      Drücken Sie ENTER, um die Nachricht anzuzeigen:

      Output

      [-- Message 1 -- 14 lines, 369 bytes --]: From sammy@example.com Tue May 19 15:40:48 2020 Date: Tue, 19 May 2020 15:40:48 +0000 To: sammy@example.com Subject: init Message-Id: <20160513220749.A278F228D9@mail.example.com> From: sammy@example.com init

      Sie können zurück zu der Nachrichtenliste gelangen, indem Sie h eingeben und dann ENTER drücken.

      Output

      >R 1 sammy@example.com 2020-05-19 15:40 14/392 init

      Beachten Sie, dass die Nachricht jetzt den Status R hat, was anzeigt, dass sie gelesen wurde.

      Da diese Nachricht nicht sehr nützlich ist, können Sie sie löschen, indem Sie d und dann ENTER drücken.

      Um zurück zum Terminal zu gelangen, geben Sie q und dann ENTER ein:

      Prüfen Sie abschließend, ob s-nail in der Lage ist, E-Mail-Nachrichten korrekt zu senden. Dazu können Sie den Inhalt einer Textdatei an den s-nail-Prozess übergeben, wie Sie es mit der init-Nachricht getan haben, die Sie im vorherigen Schritt gesendet haben.

      Beginnen Sie mit dem Schreiben einer Testnachricht in einem Texteditor:

      Geben Sie im Editor den Text ein, den Sie senden möchten:

      ~/test_message

      Hello,
      
      This is a test.  Please confirm receipt!
      

      Speichern und schließen Sie die Datei, nachdem Sie Ihre Nachricht geschrieben haben.

      Verwenden Sie dann den Befehl cat, um die Nachricht an den s-nail-Prozess zu übergeben. Sie können dies mit dem folgenden Beispiel tun, das diese Optionen verwendet:

      • -s: Dies definiert die Betreffzeile der E-Mail-Nachricht
      • -r: Eine optionale Änderung des Felds „Von:“ der E-Mail. Standardmäßig wird der Linux-Benutzer, unter dem Sie angemeldet sind, zum Ausfüllen dieses Feldes verwendet. Die Option -r ermöglicht es Ihnen, diese mit einer gültigen Adresse zu überschreiben, z. B. mit einer der Adressen, die Sie in der Datei /etc/postfix/virtual definiert haben. Zur Veranschaulichung verwendet der folgende Befehl contact@example.com.

      Stellen Sie außerdem sicher, dass Sie user@email.com in eine gültige E-Mail-Adresse ändern, auf die Sie Zugriff haben:

      • cat ~/test_message | s-nail -s 'Test email subject line' -r contact@example.com user@email.com

      Navigieren Sie dann zum Posteingang für die E-Mail-Adresse, an die Sie die Nachricht geschickt haben. Dort sehen Sie Ihre Nachricht fast sofort warten.

      Anmerkung: Wenn sich die Nachricht nicht in Ihrem Posteingang befindet, wurde sie möglicherweise an Ihren Spam-Ordner geleitet.

      Sie können Ihre gesendeten Nachrichten in Ihrem s-nail-Client anzeigen. Starten Sie den interaktiven Client erneut:

      Sie können Ihre gesendeten Nachrichten in dem E-Mail-Client anzeigen, indem Sie Folgendes eingeben:

      Die Ausgabe sieht dann so aus:

      Output

      +[/home/sammy/Maildir/]sent: 1 message 1 new ▸N 1 contact@example.com 2020-05-19 15:47 12/297 Test email subject line

      Sie können gesendete Mail mit den gleichen Befehlen verwalten, die Sie für die eingehende Mail verwenden.

      Zusammenfassung

      Sie haben Postfix nun auf Ihrem Ubuntu 20.04-Server konfiguriert. Die Verwaltung von E-Mail-Servern kann für neue Systemadministratoren eine schwierige Aufgabe sein, aber mit dieser Konfiguration sollten Sie über ausreichend MTA-E-Mail-Funktionen verfügen, um sofort loslegen zu können.



      Source link