One place for hosting & domains

      Ausführen

      Ausführen mehrerer PHP-Versionen auf einem Server mit Apache und PHP-FPM unter CentOS 7


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Der Apache-Webserver verwendet virtuelle Hosts zur Verwaltung mehrerer Domänen auf einer einzigen Instanz. In ähnlicher Weise verwendet PHP-FPM einen Daemon, um mehrere PHP-Versionen auf einer einzigen Instanz zu verwalten. Zusammen können Sie Apache und PHP-FPM verwenden, um mehrere PHP-Webanwendungen zu hosten, von denen jede eine andere Version von PHP verwendet, alle auf dem gleichen Server und alle zur gleichen Zeit. Dies ist nützlich, da verschiedene Anwendungen möglicherweise verschiedene Versionen von PHP erfordern, aber einige Server-Stacks, wie ein herkömmlich konfigurierter LAMP-Stack, nur einen verwalten können. Die Kombination von Apache mit PHP-FPM ist auch eine kosteneffizientere Lösung als das Hosting jeder Anwendung auf ihrer eigenen Instanz.

      PHP-FPM bietet auch Konfigurationsoptionen für stderr– und stdout-Protokollierung, Notfall-Neustarts und adaptives Prozess-Spawning, was bei stark ausgelasteten Sites nützlich ist. Tatsächlich ist der Einsatz von Apache mit PHP-FPM einer der besten Stacks für das Hosting von PHP-Anwendungen, insbesondere, wenn es um die Leistung geht.

      In diesem Tutorial richten Sie zwei PHP-Sites auf einer einzigen Instanz ein. Jede Site verwendet ihre eigene Domäne und jede Domäne stellt ihre eigene PHP-Version bereit. Die erste, site1.your_domain, stellt PHP 7.0 bereit. Die zweite, site2.your_domain, stellt PHP 7.2 bereit.

      Voraussetzungen

      Schritt 1 – Installieren von PHP Versionen 7.0 und 7.2 mit PHP-FPM

      Wenn die Vorkehrungen abgeschlossen sind, können Sie jetzt die PHP-Versionen 7.0 und 7.2 installieren. Das SCL (Software Collections)-Repository verwaltet zahlreiche Versionen des PHP-Stacks für das CentOS 7-System. Wenn Sie die neueste Version von PHP benötigen und diese nicht auf SCL verfügbar ist, sehen Sie stattdessen im remi PPA (persönliches Paketarchiv) nach.

      Beginnen Sie mit der Installation des SCL Repository in Ihrem System:

      • sudo yum install centos-release-scl -y

      Wir wollen uns zunächst ansehen, welche PHP 7-Versionen auf SCL verfügbar sind:

      • sudo yum list rh-php7[0-9].x86_64

      Sie sehen eine Ausgabe wie diese:

      Output

      Available Packages rh-php70.x86_64 2.3-1.el7 centos-sclo-rh rh-php71.x86_64 1-1.el7 centos-sclo-rh rh-php72.x86_64 1-2.el7 centos-sclo-rh rh-php73.x86_64 1-1.el7 centos-sclo-rh

      Sie sehen, dass die neueste Version, PHP 7.3, auch verfügbar ist. Für unsere Beispiele werden wir jedoch die Versionen 7.0 und 7.2 installieren.

      Beginnen wir mit der älteren Version. Installieren Sie rh-php70 und rh-php70-php-fpm:

      • sudo yum install rh-php70 rh-php70-php-fpm -y
      • rh-php70 ist ein Metapaket, das PHP-Anwendungen ausführt.
      • rh-php7.0-php-fpm bietet den Fast Process Manager-Interpreter, der als Daemon ausgeführt wird und Fast/CGI-Anfragen empfängt.

      Wiederholen Sie den Vorgang für PHP-Version 7.2. Installieren Sie rh-php72 und rh-php72-php-fpm.

      • sudo yum install rh-php72 rh-php72-php-fpm -y

      Führen Sie als Nächstes die folgenden Befehle aus, um mit der Verwendung der beiden Software-Sammlungen zu beginnen:

      • sudo scl enable rh-php70 bash
      • sudo scl enable rh-php72 bash

      Standardmäßig hören beide PHP-Versionen Port 9000 ab. In diesem Tutorial möchten wir jedoch zwei Versionen gleichzeitig ausführen. Wir benennen daher zwei neue Ports:

      Dazu können Sie /etc/opt/rh/rh-php70/php-fpm.d/www.conf in einem beliebigen Texteditor öffnen und 9000 überall in 9002 ändern. Speichern und schließen Sie die Datei und wiederholen Sie den Vorgang für /etc/opt/rh/rh-php72/php-fpm.d/www.conf, aber ersetzen Sie jetzt 9000 durch 9003. Alternativ können Sie diese beiden sed-Befehle für die Ersetzungen verwenden:

      • sudo sed -i 's/:9000/:9002/' /etc/opt/rh/rh-php70/php-fpm.d/www.conf
      • sudo sed -i 's/:9000/:9003/' /etc/opt/rh/rh-php72/php-fpm.d/www.conf

      Sie haben nun einen eigenen Port für jeden Ihrer PHP Dienste angegeben. Bevor die Änderungen jedoch funktionieren, müssen Sie die Ports zu Ihrer SELinux Konfiguration hinzufügen.

      SELinux ist die Kurzform für Security Enhanced Linux und ist standardmäßig in CentOS 7 aktiviert. Damit Ihre Anwendungen ausgeführt werden können, müssen Sie die neuen Ports 9002 und 9003 Ihrer SELinux Datenbank hinzufügen und den httpd Diensten zuweisen. Verwenden Sie den Befehl semanage, um diese Aufgabe auszuführen:

      • sudo semanage port -a -t http_port_t -p tcp 9002
      • sudo semanage port -a -t http_port_t -p tcp 9003

      Das Flag -a gibt an, dass Sie der Datenbank ein Objekt hinzufügen. Das Flag -t gibt die Art des Objekts an. In diesem Fall handelt es sich um http_port_t. Flag -p ordnet das tcp-Protokoll zu. Sie können mehr über SELinux und den semanage-Befehl in diesem Tutorial oder durch einen Besuch der offiziellen SELinux-Dokumentation erfahren.

      Sie können nun die PHP Dienste starten und aktivieren. Beginnen Sie mit dem Dienst rh-php70-php-fpm und aktivieren Sie ihn zum Starten beim Booten:

      • sudo systemctl start rh-php70-php-fpm
      • sudo systemctl enable rh-php70-php-fpm

      Überprüfen Sie als Nächstes den Status des rh-php70-php-fpm-Dienstes:

      • sudo systemctl status rh-php70-php-fpm

      Sie sehen eine Ausgabe wie diese:

      Output

      ● rh-php70-php-fpm.service - The PHP FastCGI Process Manager Loaded: loaded (/usr/lib/systemd/system/rh-php70-php-fpm.service; enabled; vendor preset: disabled) Active: active (running) since Sat 2020-04-18 04:49:59 UTC; 1min 6s ago Main PID: 1852 (php-fpm) Status: "Processes active: 0, idle: 5, Requests: 0, slow: 0, Traffic: 0req/sec" CGroup: /system.slice/rh-php70-php-fpm.service ├─1852 php-fpm: master process (/etc/opt/rh/rh-php70/php-fpm.conf) ├─1853 php-fpm: pool www ├─1854 php-fpm: pool www ├─1855 php-fpm: pool www ├─1856 php-fpm: pool www └─1857 php-fpm: pool www Apr 18 04:49:59 centos-s-1vcpu-1gb-blr1-01 systemd[1]: Starting The PHP FastCGI Process Manager... Apr 18 04:49:59 centos-s-1vcpu-1gb-blr1-01 systemd[1]: Started The PHP FastCGI Process Manager.

      Wiederholen Sie den Vorgang, starten Sie den rh-php72-php-fpm-Dienst und aktivieren Sie ihn, sodass er beim Booten gestartet wird:

      • sudo systemctl start rh-php72-php-fpm
      • sudo systemctl enable rh-php72-php-fpm

      Überprüfen Sie als Nächstes den Status des rh-php70-php-fpm-Dienstes:

      • sudo systemctl status rh-php72-php-fpm

      Sie sehen eine Ausgabe wie diese:

      Output

      ● rh-php72-php-fpm.service - The PHP FastCGI Process Manager Loaded: loaded (/usr/lib/systemd/system/rh-php72-php-fpm.service; enabled; vendor preset: disabled) Active: active (running) since Sat 2020-04-18 04:50:04 UTC; 1min 59s ago Main PID: 1876 (php-fpm) Status: "Processes active: 0, idle: 5, Requests: 0, slow: 0, Traffic: 0req/sec" CGroup: /system.slice/rh-php72-php-fpm.service ├─1876 php-fpm: master process (/etc/opt/rh/rh-php72/php-fpm.conf) ├─1877 php-fpm: pool www ├─1878 php-fpm: pool www ├─1879 php-fpm: pool www ├─1880 php-fpm: pool www └─1881 php-fpm: pool www Apr 18 04:50:04 centos-s-1vcpu-1gb-blr1-01 systemd[1]: Starting The PHP FastCGI Process Manager... Apr 18 04:50:04 centos-s-1vcpu-1gb-blr1-01 systemd[1]: Started The PHP FastCGI Process Manager.

      Zu diesem Zeitpunkt haben Sie zwei PHP-Versionen auf Ihrem Server installiert. Als Nächstes erstellen Sie eine Verzeichnisstruktur für jede Website, die Sie bereitstellen möchten.

      Schritt 2 — Erstellen von Verzeichnisstrukturen für beide Websites

      In diesem Abschnitt erstellen Sie für beide Websites ein Dokumentenstammverzeichnis und eine Indexseite.

      Erstellen Sie zunächst Dokumentenstammverzeichnisse sowohl für site1.your_domain als auch für site2.your_domain:

      • sudo mkdir /var/www/site1.your_domain
      • sudo mkdir /var/www/site2.your_domain

      Der Apache-Webserver wird standardmäßig als apache-Benutzer und apache-Gruppe ausgeführt. So sollten /var/www/ und alle zugehörigen Dateien und Unterverzeichnisse ebenfalls unter deren Eigentümerschaft fallen. Führen Sie die folgenden Befehle aus, um die richtigen Eigentümerschaften und Berechtigungen der Website-Stammverzeichnisse zu überprüfen:

      • sudo chown -R apache:apache /var/www/site1.your_domain
      • sudo chown -R apache:apache /var/www/site2.your_domain
      • sudo chmod -R 755 /var/www/site1.your_domain
      • sudo chmod -R 755 /var/www/site2.your_domain

      Der Befehl chown ändert die Eigentümerschaften der beiden Website-Verzeichnisse auf den apache-Benutzer und die apache-Gruppe. Der Befehl chmod ändert die Berechtigungen, die mit diesem Benutzer und der Gruppe verknüpft sind, sowie mit anderen.

      Erstellen Sie als Nächstes in jedem Stammverzeichnis Ihrer Website eine Datei info.php. Dadurch werden die PHP-Versionsinformationen jeder Website angezeigt. Beginnen Sie mit site1:

      • sudo vi /var/www/site1.your_domain/info.php

      Fügen Sie die folgende Zeile hinzu:

      /var/www/site1.your_domain/info.php

      <?php phpinfo(); ?>
      

      Speichern und schließen Sie die Datei. Kopieren Sie nun die von Ihnen erstellte Datei info.php nach site2:

      • sudo cp /var/www/site1.your_domain/info.php /var/www/site2.your_domain/info.php

      Ihr Webserver sollte nun über die Stammverzeichnisse der Dokumente verfügen, die jede Site benötigt, um Besuchern Daten zur Verfügung zu stellen. Als Nächstes konfigurieren Sie Ihren Apache-Webserver, um mit zwei verschiedenen PHP-Versionen zu arbeiten.

      Schritt 3 – Konfigurieren von Apache für beide Websites

      In diesem Abschnitt erstellen Sie zwei Konfigurationsdateien für virtuelle Hosts. Dadurch können Ihre beiden Websites gleichzeitig mit zwei verschiedenen PHP-Versionen arbeiten.

      Damit Apache diesen Inhalt bereitstellen kann, ist es erforderlich, eine virtuelle Host-Datei mit den richtigen Anweisungen zu erstellen. Sie erstellen zwei neue virtuelle Host-Konfigurationsdateien im Verzeichnis /etc/httpd/conf.d/.

      Erstellen Sie zunächst eine neue Konfigurationsdatei für einen virtuellen Host für die Website site1.your_domain. Hier weisen Sie Apache an, Inhalte mit PHP 7.0 zu rendern:

      • sudo vi /etc/httpd/conf.d/site1.your_domain.conf

      Fügen Sie folgenden Inhalt hinzu: Stellen Sie sicher, dass der Website-Verzeichnispfad, der Servername, der Port und die PHP-Version mit Ihrer Einrichtung übereinstimmen:

      /etc/httpd/conf.d/site1.your_domain.conf

      
      <VirtualHost *:80>
           ServerAdmin admin@site1.your_domain
           ServerName site1.your_domain
           DocumentRoot /var/www/site1.your_domain
           DirectoryIndex info.php
           SetHandler "proxy:fcgi://127.0.0.1:9002
           ScriptAlias /cgi-bin/ "/var/www/cgi-bin/"
           AddHandler php70-fcgi .php
           Action php70-fcgi /cgi-bin/php70.fcgi
           ErrorLog /var/log/httpd/site1.your_domain_error.log
           CustomLog /var/log/httpd/site1.your_domain_access.log combined
      </VirtualHost>
      

      Für DocumentRoot geben Sie den Pfad Ihres Website-Stammverzeichnisses ein. Für ServerAdmin geben Sie eine E-Mail an, auf die der Administrator der Site your_domain zugreifen kann. Für ServerName fügen Sie die URL für Ihre erste Subdomäne hinzu. Für SetHandler geben Sie Port 9002 an. Die verbleibenden Anweisungen konfigurieren Ihren Dienst zudem für die Bereitstellung von PHP 7.0.

      Speichern und schließen Sie die Datei.

      Erstellen Sie als Nächstes eine neue virtuelle Host-Konfigurationsdatei für die Website site2.your_domain. Geben Sie diese Subdomäne für die Bereitstellung von PHP 7.2 an:

      • sudo vi /etc/httpd/conf.d/site2.your_domain.conf

      Fügen Sie folgenden Inhalt hinzu: Stellen Sie auch hier sicher, dass der Website-Verzeichnispfad, der Servername und die PHP-Version mit Ihren eindeutigen Informationen übereinstimmen:

      /etc/httpd/conf.d/site2.your_domain.conf

      <VirtualHost *:80>
           ServerAdmin admin@site2.your_domain
           ServerName site2.your_domain
           DocumentRoot /var/www/site2.your_domain
           DirectoryIndex info.php
           SetHandler "proxy:fcgi://127.0.0.1:9003
           ScriptAlias /cgi-bin/ "/var/www/cgi-bin/"
           AddHandler php72-fcgi .php
           Action php72-fcgi /cgi-bin/php72.fcgi
           ErrorLog /var/log/httpd/site2.your_domain_error.log
           CustomLog /var/log/httpd/site2.your_domain_access.log combined
      </VirtualHost>
      

      Wenn Sie fertig sind, speichern und schließen Sie die Datei. Überprüfen Sie anschließend die Apache-Konfigurationsdatei auf etwaige Syntaxfehler:

      • sudo apachectl configtest

      Sie sehen eine Ausgabe von Syntax OK:

      Output

      Starten Sie schließlich den Apache-Dienst neu, um Ihre Änderungen zu übernehmen:

      • sudo systemctl restart httpd

      Nachdem Sie Apache nun konfiguriert haben, um jede Site zu bedienen, werden Sie sie testen, um sicherzustellen, dass die richtigen PHP-Versionen ausgeführt werden.

      Schritt 4 – Testen beider Websites

      Zu diesem Zeitpunkt haben Sie zwei Websites konfiguriert, um zwei verschiedene PHP-Versionen auszuführen. Testen Sie nun die Ergebnisse.

      Öffnen Sie Ihren Webbrowser und besuchen Sie beide Sites http://site1.your_domain und http://site2.your_domain. Sie sehen zwei Seiten, die wie folgt aussehen:

      PHP 7.0 InfoseitePHP 7.2 Infoseite

      Beachten Sie die Titel. Die erste Seite zeigt an, dass site1.your_domain PHP-Version 7.0 bereitstellt. Die zweite zeigt an, dass site2.your_domain PHP-Version 7.2 bereitstellt.

      Nachdem Sie nun Ihre Sites getestet haben, entfernen Sie die Dateien info.php. Da sie sensible Informationen über Ihren Server enthalten und für unberechtigte Benutzer zugänglich sind, stellen sie ein Sicherheitsrisiko dar. Entfernen Sie die Dateien:

      • sudo rm -rf /var/www/site1.your_domain/info.php
      • sudo rm -rf /var/www/site2.your_domain/info.php

      Sie haben nun einen einzigen CentOS 7-Server, der zwei Websites mit zwei verschiedenen PHP-Versionen verwaltet. PHP-FPM ist jedoch nicht auf diese eine Anwendung beschränkt.

      Zusammenfassung

      Sie haben nun virtuelle Hosts und PHP-FPM kombiniert, um mehrere Websites und mehrere PHP-Versionen auf einem einzigen Server bereitzustellen. Die einzige praktische Beschränkung der Anzahl der PHP-Sites und PHP-Versionen, die Ihr Apache-Dienst verarbeiten kann, ist die Verarbeitungsleistung Ihrer Instanz.

      Von hier aus können Sie die fortgeschritteneren Funktionen von PHP-FPM erkunden, wie den adaptiven Spawning-Prozess oder die Protokollierung von sdtout und stderr. Oder Sie sichern jetzt Ihre Websites. Zu diesem Zweck können Sie unserem Tutorial zum Sichern Ihrer Sites mit kostenlosen TLS/SSL-Zertifikaten von Let’s Encrypt folgen.



      Source link

      Ausführen verschiedener PHP-Versionen auf einem Server unter Verwendung von Apache und PHP-FPM unter Debian 10


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Der Apache-Webserver verwendet virtuelle Hosts zur Verwaltung mehrerer Domänen auf einer einzigen Instanz. In ähnlicher Weise verwendet PHP-FPM einen Daemon, um mehrere PHP-Versionen auf einer einzigen Instanz zu verwalten. Zusammen können Sie Apache und PHP-FPM verwenden, um mehrere PHP-Webanwendungen zu hosten, von denen jede eine andere Version von PHP verwendet, alle auf dem gleichen Server und alle zur gleichen Zeit. Dies ist nützlich, da verschiedene Anwendungen möglicherweise verschiedene Versionen von PHP erfordern, aber einige Server-Stacks, wie ein herkömmlich konfigurierter LAMP-Stack, nur einen verwalten können. Die Kombination von Apache mit PHP-FPM ist auch eine kosteneffizientere Lösung als das Hosting jeder Anwendung auf ihrer eigenen Instanz.

      PHP-FPM bietet auch Konfigurationsoptionen für stderr– und stdout-Protokollierung, Notfall-Neustarts und adaptives Prozess-Spawning, was bei stark ausgelasteten Sites nützlich ist. Tatsächlich ist der Einsatz von Apache mit PHP-FPM einer der besten Stacks für das Hosting von PHP-Anwendungen, insbesondere, wenn es um die Leistung geht.

      In diesem Tutorial richten Sie zwei PHP-Sites auf einer einzigen Instanz ein. Jede Site verwendet ihre eigene Domäne und jede Domäne stellt ihre eigene PHP-Version bereit. Die erste, site1.your_domain, stellt PHP 7.0 bereit. Die zweite, site2.your_domain, stellt PHP 7.2 bereit.

      Voraussetzungen

      Schritt 1 – Installieren von PHP Versionen 7.0 und 7.2 mit PHP-FPM

      Nachdem die Voraussetzungen erfüllt sind, installieren Sie nun PHP-Versionen 7.0 und 7.2 sowie PHP-FPM als auch mehrere zusätzliche Erweiterungen. Dazu müssen Sie jedoch zunächst das sury php-Repository zu Ihrem System hinzufügen.

      Installieren Sie zunächst mehrere erforderliche Pakete, einschließlich curl, wget und gnupg2:

      • sudo apt-get install curl wget gnupg2 ca-certificates lsb-release apt-transport-https -y

      Mit den obigen Paketen können Sie sicher auf das sury php-Repository zugreifen. sury php ist ein Drittanbieter-Repository oder PPA (Personal Package Archive). Es stellt PHP 7.4, 7.3, 7.2, 7.1 und 7.0 für das Debian-Betriebssystem bereit. Außerdem bietet es aktuellere Versionen von PHP als die offiziellen Debian 10-Repositorys und Sie können verschiedene Versionen von PHP im gleichen System installieren.

      Als Nächstes importieren Sie den Schlüssel des Pakets:

      • wget https://packages.sury.org/php/apt.gpg
      • sudo apt-key add apt.gpg

      Fügen Sie nun das Repository sury php Ihrem System hinzu:

      • echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/php7.list

      Aktualisieren Sie das Repository:

      Installieren Sie als Nächstes php7.0, php7.0-fpm, php7.0-mysql, libapache2-mod-php7.0, und libapache2-mod-fcgid mit den folgenden Befehlen:

      • sudo apt-get install php7.0 php7.0-fpm php7.0-mysql libapache2-mod-php7.0 libapache2-mod-fcgid -y
      • php7.0 ist ein Metapaket zur Ausführung von PHP-Anwendungen.
      • php7.0-fpm bietet den Fast Process Manager-Interpreter, der als Daemon ausgeführt wird und Fast/CGI-Anfragen empfängt.
      • php7.0-mysql verbindet PHP mit der MySQL-Datenbank.
      • libapahce2-mod-php7.0 stellt das PHP-Modul für den Apache-Webserver bereit.
      • libapache2-mod-fcgid enthält eine mod_fcgid, die eine Reihe von CGI-Programminstanzen startet, um gleichzeitige Anfragen zu bearbeiten.

      Wiederholen Sie den Vorgang für PHP-Version 7.2. Installieren Sie php7.2, php7.2-fpm, php7.2-mysql und libapache2-mod-php7.2.

      • sudo apt-get install php7.2 php7.2-fpm php7.2-mysql libapache2-mod-php7.2 -y

      Starten Sie nach Installation beider PHP-Versionen den Dienst php7.0-fpm:

      • sudo systemctl start php7.0-fpm

      Überprüfen Sie als Nächstes den Status des php7.0-fpm-Dienstes:

      • sudo systemctl status php7.0-fpm

      Sie sehen die folgende Ausgabe:

      Output

      ● php7.0-fpm.service - The PHP 7.0 FastCGI Process Manager Loaded: loaded (/lib/systemd/system/php7.0-fpm.service; enabled; vendor preset: enabled) Active: active (running) since Sat 2020-04-04 08:51:47 UTC; 1min 17s ago Docs: man:php-fpm7.0(8) Main PID: 13016 (php-fpm7.0) Status: "Processes active: 0, idle: 2, Requests: 0, slow: 0, Traffic: 0req/sec" Tasks: 3 (limit: 1149) Memory: 19.1M CGroup: /system.slice/php7.0-fpm.service ├─13016 php-fpm: master process (/etc/php/7.0/fpm/php-fpm.conf) ├─13017 php-fpm: pool www └─13018 php-fpm: pool www Apr 04 08:51:47 debian10 systemd[1]: Starting The PHP 7.0 FastCGI Process Manager... Apr 04 08:51:47 debian10 systemd[1]: Started The PHP 7.0 FastCGI Process Manager.

      Wiederholen Sie diesen Vorgang nun zum Starten des php7.2-fpm-Dienstes:

      • sudo systemctl start php7.2-fpm

      Und überprüfen Sie dann den Status des php7.2-fpm-Dienstes:

      • sudo systemctl status php7.2-fpm

      Sie sehen die folgende Ausgabe:

      Output

      ● php7.2-fpm.service - The PHP 7.2 FastCGI Process Manager Loaded: loaded (/lib/systemd/system/php7.2-fpm.service; enabled; vendor preset: enabled) Active: active (running) since Sat 2020-04-04 08:52:52 UTC; 1min 32s ago Docs: man:php-fpm7.2(8) Process: 22207 ExecStartPost=/usr/lib/php/php-fpm-socket-helper install /run/php/php-fpm.sock /etc/php/7.2/fpm/pool.d/www.conf 72 (code=exite Main PID: 22204 (php-fpm7.2) Status: "Processes active: 0, idle: 2, Requests: 0, slow: 0, Traffic: 0req/sec" Tasks: 3 (limit: 1149) Memory: 12.0M CGroup: /system.slice/php7.2-fpm.service ├─22204 php-fpm: master process (/etc/php/7.2/fpm/php-fpm.conf) ├─22205 php-fpm: pool www └─22206 php-fpm: pool www Apr 04 08:52:52 debian10 systemd[1]: Starting The PHP 7.2 FastCGI Process Manager... Apr 04 08:52:52 debian10 systemd[1]: Started The PHP 7.2 FastCGI Process Manager.

      Abschließend müssen Sie mehrere Module aktivieren, damit Ihr Apache2-Dienst mit mehreren PHP-Versionen arbeiten kann:

      • sudo a2enmod actions fcgid alias proxy_fcgi
      • actions wird für die Ausführung von CGI-Skripten verwendet, die auf Medientyp oder Anfragemethode basieren.

      • fcgid ist eine hochleistungsfähige Alternative zu mod_cgi, die eine ausreichende Anzahl von Instanzen des CGI-Programms zur Bearbeitung simultaner Anfragen startet.

      • alias stellt die Abbildung verschiedener Teile des Host-Dateisystems im Dokumentenbaum bereit und dient der URL-Umleitung.

      • proxy_fcgi ermöglicht Apache die Weiterleitung von Anfragen an PHP-FPM.

      Starten Sie nun den Apache-Dienst neu, um Ihre Änderungen zu übernehmen:

      • sudo systemctl restart apache2

      Zu diesem Zeitpunkt haben Sie zwei PHP-Versionen auf Ihrem Server installiert. Als Nächstes erstellen Sie eine Verzeichnisstruktur für jede Website, die Sie bereitstellen möchten.

      Schritt 2 — Erstellen von Verzeichnisstrukturen für beide Websites

      In diesem Abschnitt erstellen Sie für beide Websites ein Dokumentenverzeichnis und eine Indexseite.

      Erstellen Sie zunächst Dokument-Stammverzeichnisse sowohl für site1.your_domain als auch für site2.your_domain:

      • sudo mkdir /var/www/site1.your_domain
      • sudo mkdir /var/www/site2.your_domain

      Standardmäßig wird der Apache-Webserver als Benutzer www-data und als Gruppe www-data ausgeführt. Um sicherzustellen, dass Sie über die korrekte Eigentümerschaften und Berechtigungen für die Stammverzeichnisse Ihrer Website verfügen, führen Sie die folgenden Befehle aus:

      • sudo chown -R www-data:www-data /var/www/site1.your_domain
      • sudo chown -R www-data:www-data /var/www/site2.your_domain
      • sudo chmod -R 755 /var/www/site1.your_domain
      • sudo chmod -R 755 /var/www/site2.your_domain

      Erstellen Sie als Nächstes in jedem Stammverzeichnis Ihrer Website eine Datei info.php. Dadurch werden die PHP-Version jeder Website angezeigt. Beginnen Sie mit site1:

      • sudo nano /var/www/site1.your_domain/info.php

      Fügen Sie die folgende Zeile hinzu:

      /var/www/site1.your_domain/info.php

      <?php phpinfo(); ?>
      

      Speichern und schließen Sie die Datei. Kopieren Sie nun die von Ihnen erstellte Datei info.php nach site2:

      • sudo cp /var/www/site1.your_domain/info.php /var/www/site2.your_domain/info.php

      Ihr Webserver sollte nun über die Stammverzeichnisse der Dokumente verfügen, die jede Site benötigt, um Besuchern Daten zur Verfügung zu stellen. Als Nächstes konfigurieren Sie Ihren Apache-Webserver, um mit zwei verschiedenen PHP-Versionen zu arbeiten.

      Schritt 3 – Konfigurieren von Apache für beide Websites

      In diesem Abschnitt erstellen Sie zwei Konfigurationsdateien für virtuelle Hosts. Dadurch können Ihre beiden Websites gleichzeitig mit zwei verschiedenen PHP-Versionen arbeiten.

      Damit Apache diesen Inhalt bereitstellen kann, ist es erforderlich, eine virtuelle Host-Datei mit den richtigen Anweisungen zu erstellen. Anstatt die Standardkonfigurationsdatei unter /etc/apache2/sites-available/000-default.conf zu ändern, erstellen Sie zwei neue in dem Verzeichnis /etc/apache2/sites-available.

      Erstellen Sie zunächst eine neue Konfigurationsdatei für einen virtuellen Host für die Website site1.your_domain. Hier weisen Sie Apache an, Inhalte mit php7.0 zu rendern:

      • sudo nano /etc/apache2/sites-available/site1.your_domain.conf

      Fügen Sie folgenden Inhalt hinzu: Stellen Sie sicher, dass der Website-Verzeichnispfad, der Servername und die PHP-Version mit Ihrer Einrichtung übereinstimmen:

      /etc/apache2/sites-available/site1.your_domain.conf

      
      <VirtualHost *:80>
           ServerAdmin admin@site1.your_domain
           ServerName site1.your_domain
           DocumentRoot /var/www/site1.your_domain
           DirectoryIndex info.php
      
           <Directory /var/www/site1.your_domain>
              Options Indexes FollowSymLinks MultiViews
              AllowOverride All
              Order allow,deny
              allow from all
           </Directory>
      
          <FilesMatch .php$>
            # For Apache version 2.4.10 and above, use SetHandler to run PHP as a fastCGI process server
            SetHandler "proxy:unix:/run/php/php7.0-fpm.sock|fcgi://localhost"
          </FilesMatch>
      
           ErrorLog ${APACHE_LOG_DIR}/site1.your_domain_error.log
           CustomLog ${APACHE_LOG_DIR}/site1.your_domain_access.log combined
      </VirtualHost>
      

      In dieser Datei haben Sie die DocumentRoot auf Ihr neues Verzeichnis und ServerAdmin auf eine E-Mail aktualisiert, auf die der Administrator der Website your_domain zugreifen kann. Weiterhin haben Sue ServerName aktualisiert, der die Basisdomäne für diese Konfiguration des virtuellen Hosts festlegt, und Sie haben eine Anweisung SetHandler hinzugefügt, um PHP als fastCGI-Prozessserver auszuführen.

      Speichern und schließen Sie die Datei.

      Erstellen Sie als Nächstes eine neue Konfigurationsdatei des virtuellen Hosts für die Website site2.your_domain. Sie geben diese Subdomäne für die Bereitstellung von php7.2 an:

      • sudo nano /etc/apache2/sites-available/site2.your_domain.conf

      Fügen Sie folgenden Inhalt hinzu: Stellen Sie auch hier sicher, dass der Website-Verzeichnispfad, der Servername und die PHP-Version mit Ihrer Einrichtung übereinstimmen:

      /etc/apache2/sites-available/site2.your_domain.conf

      <VirtualHost *:80>
           ServerAdmin admin@site2.your_domain
           ServerName site2.your_domain
           DocumentRoot /var/www/site2.your_domain
           DirectoryIndex info.php  
      
           <Directory /var/www/site2.your_domain>
              Options Indexes FollowSymLinks MultiViews
              AllowOverride All
              Order allow,deny
              allow from all
           </Directory>
      
          <FilesMatch .php$>
            # For Apache version 2.4.10 and above, use SetHandler to run PHP as a fastCGI process server
            SetHandler "proxy:unix:/run/php/php7.2-fpm.sock|fcgi://localhost"
          </FilesMatch>
      
           ErrorLog ${APACHE_LOG_DIR}/site2.your_domain_error.log
           CustomLog ${APACHE_LOG_DIR}/site2.your_domain_access.log combined
      </VirtualHost>
      

      Wenn Sie fertig sind, speichern und schließen Sie die Datei. Überprüfen Sie anschließend die Apache-Konfigurationsdatei auf etwaige Syntaxfehler:

      • sudo apachectl configtest

      Sie sehen die folgende Ausgabe:

      Output

      Syntax OK

      Aktivieren Sie dann beide Konfigurationsdateien des virtuellen Hosts:

      • sudo a2ensite site1.your_domain
      • sudo a2ensite site2.your_domain

      Deaktivieren Sie nun die Standardseite, da Sie sie nicht benötigen:

      • sudo a2dissite 000-default.conf

      Starten Sie schließlich den Apache-Dienst neu, um Ihre Änderungen zu übernehmen:

      • sudo systemctl restart apache2

      Nachdem Sie Apache nun konfiguriert haben, um jede Site zu bedienen, werden Sie sie testen, um sicherzustellen, dass die richtigen PHP-Versionen ausgeführt werden.

      Schritt 4 – Testen beider Websites

      Zu diesem Zeitpunkt haben Sie zwei Websites konfiguriert, um zwei verschiedene PHP-Versionen auszuführen. Testen Sie nun die Ergebnisse.

      Öffnen Sie Ihren Webbrowser und besuchen Sie beide Sites http://site1.your_domain und http://site2.your_domain. Sie sehen zwei Seiten, die wie folgt aussehen:

      PHP 7.0 InfoseitePHP 7.2 Infoseite

      Beachten Sie die Titel. Die erste Seite zeigt an, dass site1.your_domain PHP-Version 7.0 bereitstellt. Die zweite zeigt an, dass site2.your_domain PHP-Version 7.2 bereitstellt.

      Nachdem Sie nun Ihre Sites getestet haben, entfernen Sie die Dateien info.php. Da sie sensible Informationen über Ihren Server enthalten und für unberechtigte Benutzer zugänglich sind, stellen sie eine Sicherheitsbedrohung dar. Führen Sie zur Entfernung beider Dateien die folgenden Befehle aus:

      • sudo rm -rf /var/www/site1.your_domain/info.php
      • sudo rm -rf /var/www/site2.your_domain/info.php

      Jetzt verfügen Sie über einen einzelnen Debian 10-Server, der zwei Websites mit zwei verschiedenen PHP-Versionen handhabt. PHP-FPM ist jedoch nicht auf diese eine Anwendung beschränkt.

      Zusammenfassung

      Sie haben nun virtuelle Hosts und PHP-FPM kombiniert, um mehrere Websites und mehrere PHP-Versionen auf einem einzigen Server bereitzustellen. Die einzige praktische Beschränkung der Anzahl der PHP-Sites und PHP-Versionen, die Ihr Apache-Dienst verarbeiten kann, ist die Verarbeitungsleistung Ihrer Instanz.

      Von hier aus können Sie die fortgeschritteneren Funktionen von PHP-FPM erkunden, wie den adaptiven Spawning-Prozess oder wie sdtout und stderr protokolliert werden können. Alternativ können Sie jetzt auch Ihre Websites sichern. Zu diesem Zweck können Sie unserem Tutorial zum Sichern Ihrer Sites mit kostenlosen TLS/SSL-Zertifikaten von Let’s Encrypt folgen.



      Source link

      Ausführen serverloser Funktionen mit OpenFaaS auf DigitalOcean Kubernetes


      Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Üblicherweise erfordert das Hosting einer Softwareanwendung im Internet Infrastrukturmanagement, Planung und Überwachung für ein monolithisches System. Im Gegensatz zu diesem traditionellen Ansatz gliedert die serverless Architektur (auch bekannt als Function as a Service oder FaaS) Ihre Anwendung in Funktionen auf. Bei diesen Funktionen handelt es sich um zustandslose, in sich geschlossene, ereignisausgelöste, funktional vollständige Entitäten, die über von Ihnen verwaltete APIs kommunizieren, statt über die zugrunde liegende Hardware und die explizite Bereitstellung der Infrastruktur. Die Funktionen sind vom Design her skalierbar, übertragbar, schneller einzurichten und einfacher zu testen als gewöhnliche Anwendungen. Damit die serverlose Architektur im Prinzip funktionieren kann, ist eine plattformunabhängige Art der Paketierung und Orchestrierung von Funktionen erforderlich.

      OpenFaaS ist ein Open-Source-Framework zur Implementierung der serverlosen Architektur auf Kubernetes, wobei Docker-Container zur Speicherung und Ausführung von Funktionen verwendet werden. Es ermöglicht die Paketierung eines beliebigen Programms als Container und die Verwaltung einer Funktion über die Befehlszeile oder die integrierte Web-Benutzeroberfläche. OpenFaaS verfügt über eine ausgezeichnete Unterstützung für Metriken und bietet eine automatische Skalierung der Funktionen bei steigender Nachfrage.

      In diesem Tutorial werden Sie OpenFaaS auf Ihrem DigitalOcean Kubernetes-Cluster in Ihrer Domäne einsetzen und es mit kostenlosen Let’s Encrypt TLS-Zertifikaten sichern. Sie werden auch die Web-Benutzeroberfläche erkunden und bestehende und neue Funktionen mithilfe von faas-cli, dem offiziellen Befehlszeilen-Tool, implementieren. Am Ende verfügen Sie über ein flexibles System für die Bereitstellung serverloser Funktionen.

      Voraussetzungen

      • Ein DigitalOcean Kubernetes-Cluster, bei dem Ihre Verbindung standardmäßig als kubectl konfiguriert ist. Der Cluster muss über mindestens 8 GB RAM und 4 für OpenFaaS verfügbare CPU-Cores verfügen (bei stärkerer Nutzung sind mehr erforderlich). Eine Anleitung zur Konfiguration von kubectl finden Sie unter dem Schritt Verbinden mit Ihrem Cluster, wenn Sie Ihren Cluster erstellen. Um einen Kubernetes-Cluster in DigitalOcean zu erstellen, lesen Sie unser Dokument Kubernetes Schnellstart.
      • Auf Ihrem lokalen Rechner installiertes Docker. Folgen Sie den Schritten 1 und 2 für Ihre Distribution in Installieren von Docker.
      • Einen Account bei Docker Hub zur Speicherung von Docker-Images, die Sie in diesem Tutorial erstellen werden.
      • Auf Ihrem lokalen Rechner installiertes faas-cli, das offizielle CLI-Tool zur Verwaltung von OpenFaaS. Anweisungen für mehrere Plattformen finden Sie in den offiziellen Dokumentationen.
      • Auf Ihrem lokalen Rechner installierten Helm-Paketmanager. Schließen Sie dazu Schritt 1 ab und fügen Sie das Repository stable von Schritt 2 des Tutorials Installieren von Software auf Kubernetes-Clustern mit dem Helm 3-Paketmanager hinzu.
      • In Ihrem Cluster mit Helm installierten Nginx Ingress Controller und Cert Manager, um OpenFaaS mit Ingress-Ressourcen freizugeben. Folgen Sie dazu den Anweisungen unter Einrichten eines Nginx Ingress unter DigitalOcean Kubernetes mit Helm.
      • Ein vollständig registrierter Domänenname zum Hosten von OpenFaaS, der auf den vom Nginx Ingress verwendeten Load Balancer verweist. Dieses Tutorial verwendet durchgehend openfaas.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.

      Anmerkung: Der von Ihnen in diesem Tutorial verwendete Domänenname muss sich von dem Domänennamen unterscheiden, der in dem vorbereitenden Tutorial Einrichten eines Nginx Ingress auf DigitalOcean Kubernetes verwendet wird.

      Schritt 1 – Installieren von OpenFaaS mit Helm

      In diesem Schritt installieren Sie OpenFaaS mit Helm auf Ihrem Kubernetes-Cluster und stellen es in Ihrer Domäne zur Verfügung.

      Als Teil der Voraussetzung des Nginx Ingress Controllers haben Sie Beispieldienste und einen Ingress erstellt. Sie werden sie in diesem Tutorial nicht benötigen, sodass Sie diese durch Ausführen der folgenden Befehle löschen können:

      • kubectl delete -f hello-kubernetes-first.yaml
      • kubectl delete -f hello-kubernetes-second.yaml
      • kubectl delete -f hello-kubernetes-ingress.yaml

      Da Sie Funktionen als Kubernetes-Objekte bereitstellen werden, ist es hilfreich, sie und OpenFaaS selbst in getrennten Namespaces in Ihrem Cluster zu speichern. Der Namespace von OpenFaaS wird als openfaas bezeichnet und der Namespace der Funktionen ist openfaas-fn. Erstellen Sie diese in Ihrem Cluster, indem Sie den folgenden Befehl ausführen:

      • kubectl apply -f https://raw.githubusercontent.com/openfaas/faas-netes/master/namespaces.yml

      Sie sehen die folgende Ausgabe:

      Output

      namespace/openfaas created namespace/openfaas-fn created

      Als Nächstes müssen Sie das OpenFaaS Helm-Repository hinzufügen, das das OpenFaaS-Chart hostet. Führen Sie dazu folgenden Befehl aus:

      • helm repo add openfaas https://openfaas.github.io/faas-netes/

      Helm wird die folgende Ausgabe anzeigen:

      Output

      "openfaas" has been added to your repositories

      Aktualisieren Sie den Chart-Cache von Helm:

      Sie sehen die folgende Ausgabe:

      Output

      Hang tight while we grab the latest from your chart repositories... ...Successfully got an update from the "openfaas" chart repository ...Successfully got an update from the "jetstack" chart repository ...Successfully got an update from the "stable" chart repository Update Complete. ⎈ Happy Helming!⎈

      Bevor Sie OpenFaaS installieren, müssen Sie Chart-Parameter anpassen. Sie werden diese auf Ihrem lokalen Rechner in einer Datei namens values.yaml speichern. Erstellen und öffnen Sie die Datei mit Ihrem Texteditor:

      Fügen Sie die folgenden Zeilen hinzu:

      values.yaml

      functionNamespace: openfaas-fn
      generateBasicAuth: true
      
      ingress:
        enabled: true
        annotations:
          kubernetes.io/ingress.class: "nginx"
        hosts:
          - host: openfaas.your_domain
            serviceName: gateway
            servicePort: 8080
            path: /
      

      Zuerst geben Sie den Namespace an, in dem Funktionen gespeichert werden, indem Sie openfaas-fn der Variablen functionNamespace zuweisen. Indem Sie generateBasicAuth auf true setzen, weisen Sie Helm an, eine obligatorische Authentifizierung beim Zugriff auf die OpenFaaS Web-Benutzeroberfläche einzurichten und eine Kombination von Admin-Benutzername und Passwort für Sie zu erzeugen.

      Dann aktivieren Sie die Ingress-Erstellung und konfigurieren sie weiter, um den Nginx Ingress-Controller zur Bereitstellung des OpenFaaS-Dienstes gateway in Ihrer Domäne zu verwenden.

      Denken Sie daran, openfaas.your_domain durch Ihre gewünschte Domäne aus den Voraussetzungen zu ersetzen. Wenn Sie fertig sind, speichern und schließen Sie die Datei.

      Installieren Sie zum Schluss OpenFaaS in den Namespace openfaas mit den angepassten Werten:

      • helm upgrade openfaas --install openfaas/openfaas --namespace openfaas -f values.yaml

      Sie sehen die folgende Ausgabe:

      Output

      Release "openfaas" does not exist. Installing it now. NAME: openfaas LAST DEPLOYED: ... NAMESPACE: openfaas STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: To verify that openfaas has started, run: kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas" To retrieve the admin password, run: echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode)

      Die Ausgabe zeigt, dass die Installation erfolgreich war. Führen Sie den folgenden Befehl aus, um das Passwort für den Account admin zu ermitteln:

      • echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode) | tee openfaas-password.txt

      Das entschlüsselte Passwort wird in die Ausgabe und gleichzeitig mit tee in eine Datei namens openfaas-password.txt geschrieben. Notieren Sie sich die Ausgabe, bei der es sich um Ihr OpenFaaS-Passwort für das Konto admin handelt.

      Durch Ausführen des folgenden Befehls können Sie beobachten, wie OpenFaaS-Container verfügbar werden:

      • kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"

      Wenn alle aufgelisteten Bereitstellungen ready sind, geben Sie zum Beenden STRG + C ein.

      Sie können nun in Ihrem Webbrowser zu der angegebenen Domäne navigieren. Geben Sie bei Aufforderung admin als Benutzername und das zugehörige Passwort ein. Sie sehen dann die Web-Benutzeroberfläche von OpenFaaS:

      OpenFaaS – Leeres Bedienfeld

      Sie haben OpenFaaS erfolgreich installiert und das Bedienfeld in Ihrer Domäne verfügbar gemacht. Als Nächstes sichern Sie es mit kostenlosen TLS-Zertifikaten von Let’s Encrypt.

      Schritt 2 – Aktivieren von TLS für Ihre Domäne

      In diesem Schritt sichern Sie Ihre ungeschützte Domäne mit Let’s Encrypt-Zertifikaten, die vom Zertifikatsmanager bereitgestellt werden.

      Dazu müssen Sie die Ingress-Konfiguration in values.yaml bearbeiten. Öffnen Sie sie zum Bearbeiten:

      Fügen Sie die hervorgehobenen Zeilen hinzu:

      values.yaml

      generateBasicAuth: true
      
      ingress:
        enabled: true
        annotations:
          kubernetes.io/ingress.class: "nginx"
          cert-manager.io/cluster-issuer: letsencrypt-prod
        tls:
          - hosts:
              - openfaas.your_domain
            secretName: openfaas-crt
        hosts:
          - host: openfaas.your_domain
            serviceName: gateway
            servicePort: 8080
            path: /
      

      Der Block tls definiert, in welchem Secret die Zertifikate für ihre (unter hosts aufgelisteten) Seiten ihre Zertifikate speichern, die der ClusterIssuer letsencrypt-prod ausstellt. In der Regel muss das angegebene Secret für jeden Ingress in Ihrem Cluster unterschiedlich sein.

      Vergessen Sie nicht, openfaas.your_domain​​​ durch Ihre gewünschte Domäne zu ersetzen. Speichern und schließen Sie danach die Datei.

      Wenden Sie die Änderungen in Ihrem Cluster an, indem Sie folgenden Befehl ausführen:

      • helm upgrade openfaas --install openfaas/openfaas --namespace openfaas -f values.yaml

      Sie sehen die folgende Ausgabe:

      Output

      Release "openfaas" has been upgraded. Happy Helming! NAME: openfaas LAST DEPLOYED: ... NAMESPACE: openfaas STATUS: deployed REVISION: 2 TEST SUITE: None NOTES: To verify that openfaas has started, run: kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas" To retrieve the admin password, run: echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode)

      Sie müssen einige Minuten warten, bis die Server von Let’s Encrypt ein Zertifikat für Ihre Domäne ausstellen. In der Zwischenzeit können Sie den Fortschritt verfolgen, indem Sie sich die Ausgabe des folgenden Befehls ansehen:

      • kubectl describe certificate openfaas-crt -n openfaas

      Das Ende der Ausgabe wird ähnlich wie dieses aussehen:

      Output

      Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal GeneratedKey 24m cert-manager Generated a new private key Normal Requested 16m cert-manager Created new CertificateRequest resource "openfaas-crt-1017759607" Normal Issued 16m cert-manager Certificate issued successfully

      Wenn die letzte Ausgabezeile Certificate issued successfully lautet, können Sie die Ausgabe durch Drücken von STRG + C beenden. Sie sehen das Vorhängeschloss links neben der Adressleiste in Ihrem Browser, das anzeigt, dass Ihre Verbindung sicher ist.

      Sie haben Ihre OpenFaaS-Domäne mit kostenlosen TLS-Zertifikaten von Let’s Encrypt gesichert. Jetzt werden Sie die Web-Benutzeroberfläche verwenden und Funktionen von dort aus verwalten.

      Schritt 3 – Bereitstellen von Funktionen über die Web-Benutzeroberfläche

      In diesem Abschnitt werden Sie die Web-Benutzeroberfäche von OpenFaaS erkunden und dann Funktionen von dort bereitstellen, verwalten und aufrufen.

      Die Web-Benutzeroberfläche von OpenFaaS verfügt über zwei Hauptteile: Auf der linken Seite eine Spalte, in der die bereitgestellten Funktionen aufgelistet werden, und das zentrale Bedienfeld, in dem Sie detaillierte Informationen über eine ausgewählte Funktion sehen und mit dieser interagieren können.

      Um eine neue Funktion bereitzustellen, klicken Sie oben links unter dem OpenFaaS-Logo auf die Schaltfläche Deploy New Function. Es wird ein Dialogfeld angezeigt, in dem Sie aufgefordert werden, eine Funktion auszuwählen:

      OpenFaaS – Dialogfeld Bereitstellen einer neuen Funktion

      Die Registerkarte FROM STORE listet vorgefertigte Funktionen aus dem offiziellen OpenFaaS Function Store auf, die Sie sofort bereitstellen können. Jede Funktion wird mit einer kurzen Beschreibung angezeigt und Sie können das Link-Symbol rechts neben einer Funktion auswählen, um einen Blick auf ihren Quellcode zu werfen. Um eine Store-Funktion aus der Liste bereitzustellen, wählen Sie diese aus und klicken Sie dann auf die Schaltfläche DEPLOY.

      Sie können auch Ihre eigene Funktion bereitstellen, indem Sie zu der Registerkarte CUSTOM wechseln:

      OpenFaaS – Bereitstellen einer benutzerdefinierten Funktion

      Hier müssen Sie ein Docker-Image Ihrer Funktion angeben, das speziell für OpenFaaS konfiguriert und in einer Docker-Registrierung (wie z. B. Docker Hub) verfügbar ist. In diesem Schritt stellen Sie eine vorgefertigte Funktion aus dem OpenFaaS Store bereit. Im nächsten Schritt erstellen Sie benutzerdefinierte Funktionen und stellen diese im Docker Hub bereit.

      Sie stellen die Funktion NodeInfo bereit, die Informationen über den Rechner zurückgibt, auf dem sie bereitgestellt wird, wie CPU-Architektur, Anzahl der Cores, gesamt verfügbarer RAM-Speicher und Betriebszeit (in Sekunden).

      Wählen Sie aus der Liste der Store-Funktionen NodeInfo und klicken Sie auf DEPLOY. Es wird bald in der Liste der bereitgestellten Funktionen angezeigt.

      OpenFaaS – NodeInfo bereitgestellt

      Wählen Sie sie aus. Im mittleren Teil des Bildschirms sehen sie grundlegende Informationen über die bereitgestellte Funktion.

      OpenFaaS – Info über bereitgestellte Funktion

      Der Status der Funktion wird in Echtzeit aktualisiert und sollte schnell zu Ready wechseln. Wenn über längere Zeit Not Ready angezeigt wird, ist es sehr wahrscheinlich, dass Ihrem Cluster die Ressourcen fehlen, um einen neuen Pod zu akzeptieren. Im Abschnitt Größenänderung von Droplets finden Sie Informationen darüber, wie Sie dies beheben können.

      Sobald Ready erscheint, ist die bereitgestellte Funktion unter der angegebenen URL zugänglich. Um sie zu testen, können Sie in Ihrem Browser zu der URL navigieren oder sie über das Feld Invoke function aufrufen, das sich unter der Funktionsinfo befindet.

      OpenFaaS – Bereitgestellte Funktion aufrufen

      Sie können zwischen Text, JSON und Download wählen, um die Art der Antwort anzugeben, die Sie erwarten. Wenn Sie möchten, dass die Abfrage ein POST anstelle von GET ist, können Sie im Feld Request body Abfragedaten bereitstellen.

      Um die Funktion nodeinfo aufzurufen, klicken Sie auf die Schaltfläche INVOKE. OpenFaaS erstellt und führt eine HTTP-Abfrage gemäß den gewählten Optionen aus und füllt die Antwortfelder mit den empfangenen Daten aus.

      OpenFaaS – Antwort der Funktion nodeinfo

      Der Antwortstatus ist HTTP 200 OK. Das bedeutet, dass die Abfrage erfolgreich ausgeführt wurde. Response body enthält Systeminformationen, die die Funktion NodeInfo sammelt, d. h. sie ist zugänglich und funktioniert korrekt.

      Um eine Funktion zu löschen, wählen Sie sie aus der Liste aus und klicken Sie auf das Mülleimer-Symbol in der rechten oberen Ecke der Seite. Wenn Sie dazu aufgefordert werden, klicken Sie zur Bestätigung auf OK. Der Status der Funktion wechselt zu Not Ready (was bedeutet, dass sie aus dem Cluster entfernt wird) und die Funktion wird bald nicht mehr auf der Benutzeroberfläche vorhanden sein.

      In diesem Schritt haben Sie die Web-Benutzeroberfläche von OpenFaaS verwendet sowie Funktionen von dort bereitgestellt und verwaltet. Sie werden nun sehen, wie Sie OpenFaaS-Funktionen über die Befehlszeile bereitstellen und verwalten können.

      Schritt 4 – Verwalten von Funktionen mit faas-cli

      In diesem Abschnitt konfigurieren Sie die faas-cli für die Arbeit mit Ihrem Cluster. Anschließend werden Sie Ihre vorhandenen Funktionen über die Befehlszeile bereitstellen und verwalten.

      Um zu vermeiden, dass Sie Ihre OpenFaaS-Domäne bei jeder Ausführung der faas-cli angeben müssen, speichern Sie sie in einer Umgebungsvariable namens OPENFAAS_URL, deren Wert die faas-cli automatisch abholt und während der Ausführung verwendet.

      Öffnen Sie .bash_profile in Ihrem Stammverzeichnis zur Bearbeitung:

      Fügen Sie die folgende Zeile hinzu:

      ~/.bash_profile

      . . .
      export OPENFAAS_URL=https://openfaas.your_domain
      

      Denken Sie daran, openfaas.your_domain​​​ durch Ihre gewünschte Domäne zu ersetzen. Speichern und schließen Sie danach die Datei.

      Um sich nicht erneut anmelden zu müssen, werten Sie die Datei manuell aus:

      Stellen Sie nun sicher, dass Sie faas-cli auf Ihrem lokalen Rechner installiert haben. Falls Sie es noch nicht installiert haben, folgen Sie den Anleitungen in den offiziellen Dokumentationen.

      Richten Sie dann Ihre Anmeldedaten ein, indem Sie den folgenden Befehl ausführen:

      • cat ~/openfaas-password.txt | faas-cli login --username admin --password-stdin

      Die Ausgabe sieht ungefähr so aus:

      Output

      Calling the OpenFaaS server to validate the credentials... credentials saved for admin https://openfaas.your_domain

      Um eine Funktion aus dem Store bereitzustellen, führen Sie den folgenden Befehl aus:

      • faas store deploy function_name

      Sie können die Bereitstellung von nodeinfo versuchen, indem Sie Folgendes ausführen:

      • faas store deploy nodeinfo

      Sie sehen eine Ausgabe wie die folgende:

      Output

      Deployed. 202 Accepted. URL: https://openfaas.your_domain/function/nodeinfo

      Um bereitgestellte Funktionen auflisten zu können, führen Sie faas list aus:

      Ihre vorhandenen Funktionen werden angezeigt:

      Output

      Function Invocations Replicas nodeinfo 0 1

      Um detaillierte Informationen über eine bereitgestellte Funktion zu erhalten, verwenden Sie faas describe:

      Die Ausgabe wird ähnlich dieser sein:

      Name:                nodeinfo
      Status:              Ready
      Replicas:            1
      Available replicas:  1
      Invocations:         0
      Image:               functions/nodeinfo-http:latest
      Function process:
      URL:                 https://openfaas.your_domain/function/nodeinfo
      Async URL:           https://openfaas.your_domain/async-function/nodeinfo
      Labels:              faas_function : nodeinfo
                           uid : 514253614
      Annotations:         prometheus.io.scrape : false
      

      Sie können eine Funktion mit faas invoke aufrufen:

      Sie erhalten die folgende Meldung:

      Output

      Reading from STDIN - hit (Control + D) to stop.

      Dann können Sie einen Request Body bereitstellen. Wenn Sie dies tun, ist die Methode POST anstelle von GET. Wenn Sie die Dateneingabe abgeschlossen haben oder die Anforderung GET sein soll, drücken Sie STRG + D. faas-cli führt dann die abgeleitete Abfrage aus und gibt die Antwort aus, ähnlich wie bei der Web-Benutzeroberfläche.

      Zum Löschen einer Funktion führen Sie faas remove aus:

      Sie erhalten die folgende Ausgabe:

      Output

      Deleting: nodeinfo. Removing old function.

      Führen Sie faas list erneut aus, um zu sehen, dass nodeinfo entfernt wurde.

      Output

      Function Invocations Replicas

      In diesem Schritt haben Sie Funktionen in Ihrem Cluster von der Befehlszeile aus mit Hilfe von faas-cli bereitgestellt, aufgelistet, aufgerufen und entfernt. im nächsten Schritt erstellen Sie Ihre eigene Funktion und stellen sie in Ihrem Cluster bereit.

      Schritt 5 – Erstellen und Bereitstellen einer neuen Funktion

      Erstellen Sie nun eine Beispielfunktion von Node.JS unter Verwendung von faas-cli und stellen Sie diese auf Ihrem Cluster bereit.

      Die daraus resultierende Funktion wird als Docker-Container gepackt und auf Docker Hub veröffentlicht. Um Container veröffentlichen zu können, müssen Sie sich anmelden, indem Sie den folgenden Befehl ausführen:

      Geben Sie Ihren Docker Hub-Benutzernamen und Ihr Passwort ein, wenn Sie zum Beenden des Anmeldevorgangs aufgefordert werden.

      Speichern Sie die Beispielfunktion Node.JS in einem Ordner namens sample-js-function. Erstellen Sie diese mit dem folgenden Befehl:

      Navigieren Sie dorthin:

      Füllen Sie das Verzeichnis mit der Vorlage einer JS-Funktion, indem Sie den folgenden Befehl ausführen:

      • faas new sample-js --lang node

      Die Ausgabe sieht in etwa folgendermaßen aus:

      Output

      2020/03/24 17:06:08 No templates found in current directory. 2020/03/24 17:06:08 Attempting to expand templates from https://github.com/openfaas/templates.git 2020/03/24 17:06:10 Fetched 19 template(s) : [csharp csharp-armhf dockerfile go go-armhf java11 java11-vert -x java8 node node-arm64 node-armhf node12 php7 python python-armhf python3 python3-armhf python3-debian ru by] from https://github.com/openfaas/templates.git Folder: sample-js created. ___ _____ ____ / _ _ __ ___ _ __ | ___|_ _ __ _/ ___| | | | | '_ / _ '_ | |_ / _` |/ _` ___ | |_| | |_) | __/ | | | _| (_| | (_| |___) | ___/| .__/ ___|_| |_|_| __,_|__,_|____/ |_| Function created in folder: sample-js Stack file written: sample-js.yml ...

      Wie in der Ausgabe geschrieben, befindet sich der Code für die Funktion selbst im Ordner sample-js, während sich die OpenFaaS-Konfiguration für die Funktion in der Datei sample-js.yaml befindet. Unter dem Verzeichnis sample-js (das einem regulären Node.JS-Projekt ähnelt) befinden sich zwei Dateien, handler.js und package.json.

      handler.js enthält tatsächlichen JS-Code, der eine Antwort zurückgibt, wenn die Funktion aufgerufen wird. Der Inhalt des Handlers sieht wie folgt aus:

      sample-js-function/sample-js/handler.js

      "use strict"
      
      module.exports = async (context, callback) => {
          return {status: "done"}
      }
      

      Er exportiert eine Lambda-Funktion mit zwei Parametern, einem Kontext mit Abfragedaten und einem Callback, mit dem Sie Antwortdaten zurückübergeben können, anstatt sie nur zurückzugeben.

      Öffnen Sie diese Datei zur Bearbeitung:

      • nano sample-js/handler.js

      Ändern Sie die hervorgehobene Zeile wie folgt:

      sample-js-function/sample-js/handler.js

      "use strict"
      
      module.exports = async (context, callback) => {
          return {status: "<h1>Hello Sammy!</h1>"}
      }
      

      Wenn Sie fertig sind, speichern und schließen Sie die Datei. Diese OpenFaaS-Funktion wird, wenn sie aufgerufen wird, Hello Sammy! in die Antwort schreiben.

      Öffnen Sie als Nächstes die Konfigurationsdatei zur Bearbeitung:

      Sie wird wie folgt aussehen:

      sample-js-function/sample-js.yml

      version: 1.0
      provider:
        name: openfaas
        gateway: https://openfaas.your_domain
      functions:
        sample-js:
          lang: node
          handler: ./sample-js
          image: sample-js:latest
      

      Für den provider gibt sie openfaas und ein Standard-Gateway an. Dann definiert sie die Funktion sample-js, gibt ihre Sprache (node), ihren Handler und den Namen des Docker-Image an, den Sie ändern müssen, um den Benutzernamen Ihres Docker Hub-Accounts einzufügen:

      sample-js-function/sample-js.yml

      version: 1.0
      provider:
        name: openfaas
        gateway: http://127.0.0.1:8080
      functions:
        sample-js:
          lang: node
          handler: ./sample-js
          image: your_docker_hub_username/sample-js:latest
      

      Speichern und schließen Sie die Datei.

      Erstellen Sie dann das Docker-Image, verschieben Sie es zum Docker-Hub und stellen Sie es in Ihrem Cluster bereit, und zwar gleichzeitig, indem Sie den folgenden Befehl ausführen:

      Es wird eine umfangreiche Ausgabe (hauptsächlich von Docker) erfolgen, die so endet:

      Output

      . . . [0] < Pushing sample-js [your_docker_hub_username/sample-js:latest] done. [0] Worker done. Deploying: sample-js. Deployed. 202 Accepted. URL: https://openfaas.your_domain/function/sample-js

      Rufen Sie Ihre neu bereitgestellte Funktion auf, um sicherzustellen, dass sie funktioniert:

      Drücken Sie STRG + D. Sie sehen die folgende Ausgabe:

      Output

      <h1>Hello Sammy!</h1>

      Das bedeutet, dass die Funktion gepackt und korrekt bereitgestellt wurde.

      Sie können die Funktion entfernen, indem Sie Folgendes ausführen:

      Sie haben nun erfolgreich eine benutzerdefinierte Node.JS-Funktion auf Ihrer OpenFaaS-Instanz in Ihrem Cluster erstellt und bereitgestellt.

      Zusammenfassung

      Sie haben OpenFaaS auf Ihrem DigitalOcean Kubernetes-Cluster bereitgestellt und können nun sowohl vorgefertigte als auch benutzerdefinierte Funktionen bereitstellen. Jetzt sind Sie in der Lage, die Function-as-a-Service-Architektur zu implementieren, was die Ressourcennutzung erhöhen und Leistungsverbesserungen für Ihre Anwendungen bewirken kann.

      Wenn Sie mehr über erweiterte OpenFaaS-Funktionen erfahren möchten, wie z. B. die automatische Skalierung für Ihre eingesetzten Funktionen und die Überwachung ihrer Leistung, besuchen Sie die offizielle Dokumentation.



      Source link