One place for hosting & domains

      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

      Installieren und Verwenden von ClickHouse auf Debian 10


      Der Autor hat den Free and Open Source Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      ClickHouse ist eine Open-Source-basierte, spaltenorientierte Analysedatenbank, die von Yandex für OLAP- und Big-Data-Anwendungsfälle erstellt wurde. Unterstützung von ClickHouse für eine echtzeitbasierte Verarbeitung von Abfragen sorgt dafür, dass sich ClickHouse für Anwendungen eignet, die in Sekundenbruchteilen Ergebnisse erfordern. Die Abfragesprache von ClickHouse ist ein SQL-Dialekt, der leistungsfähige deklarative Abfragefunktionen bietet, während Endbenutzer von Vertrautheit und einer flacheren Lernkurve profitieren.

      Spaltenorientierte Datenbanken speichern Einträge in nach Spalten (und nicht nach Zeilen) gruppierten Blöcken. Da Daten für Spalten, die in der Abfrage fehlen, nicht geladen werden, brauchen spaltenorientierte Datenbanken beim Ausführen von Abfragen weniger Zeit zum Lesen von Daten. Dadurch können diese Datenbanken bei bestimmten Workloads (wie z.B. OLAP) Ergebnisse wesentlich schneller berechnen als herkömmliche zeilenbasierte Systeme.

      Online Analytics Processing (OLAP)-Systeme ermöglichen es, große Mengen von Daten zu organisieren und komplexe Abfragen durchzuführen. Sie können Petabytes von Daten verwalten und Abfrageergebnisse schnell zurückgeben. Somit eignet sich OLAP gut für Bereiche wie Datenwissenschaft und geschäftliche Analysen.

      In diesem Tutorial installieren Sie den ClickHouse-Datenbankserver sowie den Client auf Ihrem Rechner. Sie verwenden das DBMS für typische Aufgaben und aktivieren optional den Remotezugriff von einem anderen Server, damit Sie sich von einem anderen Rechner aus mit der Datenbank verbinden können. Dann testen Sie ClickHouse, indem Sie Beispieldaten von Websitebesuchen modellieren und abfragen.

      Voraussetzungen

      • Ein Debian 10-Betriebssystem mit einem sudo-aktivierten non-root user und mit eingerichteter Firewall. Folgen Sie dem Tutorial zur Ersteinrichtung des Servers, um den Benutzer zu erstellen und die Firewall einzurichten.
      • (Optional) Ein sekundäres Debian 10-Betriebssystem mit einem sudo-aktivierten non-root user und mit eingerichteter Firewall. Folgen Sie dem Tutorial zur Ersteinrichtung des Servers.

      Schritt 1 — Installieren von ClickHouse

      In diesem Abschnitt installieren Sie die ClickHouse-Server- und Client-Programme mit apt.

      Stellen Sie zunächst eine SSH-Verbindung mit Ihrem Server her durch Ausführung von:

      dirmngr ist ein Server für die Verwaltung von Zertifikaten und Schlüsseln. Er wird benötigt, um Remote-Repository-Schlüssel zu aktivieren und zu verifizieren. Installieren Sie den Server durch Ausführung von:

      Yandex pflegt ein APT-Repository, das über die neueste Version von ClickHouse verfügt. Fügen Sie den GPG-Schlüssel des Repository hinzu, damit Sie validierte ClickHouse-Pakete sicher herunterladen können:

      • sudo apt-key adv --keyserver keyserver.ubuntu.com --recv E0C56BD4

      Sie werden eine Ausgabe sehen, die der folgenden ähnelt:

      Output

      Executing: /tmp/apt-key-gpghome.JkkcKnBAFY/gpg.1.sh --keyserver keyserver.ubuntu.com --recv E0C56BD4 gpg: key C8F1E19FE0C56BD4: public key "ClickHouse Repository Key <milovidov@yandex-team.ru>" imported gpg: Total number processed: 1 gpg: imported: 1

      Die Ausgabe bestätigt, dass die Verifizierung erfolgreich war und der Schlüssel hinzugefügt wurde.

      Fügen Sie das Repository Ihrer Liste mit APT-Repositorys hinzu, indem Sie Folgendes ausführen:

      • echo "deb http://repo.yandex.ru/clickhouse/deb/stable/ main/" | sudo tee /etc/apt/sources.list.d/clickhouse.list

      Hier haben Sie die Ausgabe von echo an sudo tee weitergeleitet, damit sich diese Ausgabe in einer Datei mit Root-Besitz ausgeben lässt.

      Führen Sie nun apt update aus, um Ihre Pakete zu aktualisieren:

      Die Pakete clickhouse-server und clickhouse-client stehen nun für die Installation bereit.

      Ab ClickHouse-Version 19.13.3 werden einige OpenSSL 1.1.1-Konfigurationen wie MinProtocol und CipherVersion nicht richtig gelesen. Um das Problem der fehlenden Kompatibilität zu umgehen, ändern Sie die OpenSSL-Konfigurationsdatei und kommentieren Sie die Zeile ssl_conf = ssl_sect in /etc/ssl/openssl.cnf aus.

      Bearbeiten Sie die Konfigurationsdatei, indem Sie Folgendes ausführen:

      • sudo nano /etc/ssl/openssl.cnf

      Kommentieren Sie dann die Zeile mit ssl_conf = ssl_sect aus, damit sie wie die folgende Datei aussieht:

      /etc/ssl/openssl.cnf

      ...
      
      tsa_name        = yes   # Must the TSA name be included in the reply?
                      # (optional, default: no)
      ess_cert_id_chain   = no    # Must the ESS cert id chain be included?
                      # (optional, default: no)
      ess_cert_id_alg     = sha1  # algorithm to compute certificate
                      # identifier (optional, default: sha1)
      [default_conf]
      #ssl_conf = ssl_sect
      
      [ssl_sect]
      ...
      

      Nachdem Sie die OpenSSL-Konfigurationsdatei gepatcht haben, können Sie nun die ClickHouse-Server- und Client-Pakete installieren. Installieren Sie sie mit:

      • sudo apt install clickhouse-server clickhouse-client

      Bei der Installation werden Sie auch dazu aufgefordert, ein Passwort für den standardmäßigen ClickHouse-Benutzer festzulegen.

      Sie haben den ClickHouse-Server und- Client erfolgreich installiert. Sie können den Datenbankdienst nun starten und überprüfen, ob er richtig ausgeführt wird.

      Schritt 2 — Starten des Dienstes

      Das im vorherigen Abschnitt installierte Paket clickhouse-server erstellt einen systemd-Dienst, der Aktionen wie Starten, Anhalten und Neustart des Datenbankservers ausführt. systemd ist ein init-System für Linux, das der Initialisierung und Verwaltung von Diensten dient. In diesem Abschnitt starten Sie den Dienst und überprüfen, ob er richtig ausgeführt wird.

      Starten Sie den Dienst clickhouse-server, indem Sie Folgendes ausführen:

      • sudo service clickhouse-server start

      Der vorherige Befehl wird keine Ausgabe anzeigen. Um zu überprüfen, ob der Dienst erfolgreich ausgeführt wird, führen Sie Folgendes aus:

      • sudo service clickhouse-server status

      Sie werden eine Ausgabe ähnlich der folgenden sehen:

      Output

      ● clickhouse-server.service - ClickHouse Server (analytic DBMS for big data) Loaded: loaded (/etc/systemd/system/clickhouse-server.service; enabled; vendor preset: enabled) Active: active (running) since Sat 2018-12-22 07:23:20 UTC; 1h 9min ago Main PID: 27101 (ClickHouse-serv) Tasks: 34 (limit: 1152) CGroup: /system.slice/ClickHouse-server.service └─27101 /usr/bin/ClickHouse-server --config=/etc/ClickHouse-server/config.xml

      Die Ausgabe gibt an, dass der Server ausgeführt wird.

      Sie haben den ClickHouse-Server erfolgreich gestartet und können nun das CLI-Programm clickhouse-client verwenden, um eine Verbindung zum Server herzustellen.

      Schritt 3 — Erstellen von Datenbanken und Tabellen

      In ClickHouse können Sie Datenbanken erstellen und löschen, indem Sie SQL-Anweisungen direkt in der interaktiven Datenbankaufforderung ausführen. Anweisungen bestehen aus Befehlen, die einer bestimmten Syntax folgen, und den Datenbankserver dazu bringen, eine angeforderte Operation mit allen erforderlichen Daten auszuführen. Erstellen Sie Datenbanken, indem Sie die Syntax CREATE DATABASE table_name verwenden. Um eine Datenbank zu erstellen, starten Sie zunächst eine Client-Sitzung, indem Sie folgenden Befehl ausführen:

      • clickhouse-client --password

      Sie werden dazu aufgefordert, das Passwort einzugeben, das Sie bei der Installation festgelegt haben – geben Sie es ein, um die Client-Sitzung erfolgreich zu starten.

      Mit dem vorherigen Befehl können Sie sich in der Eingabeaufforderung des Clients anmelden, wo Sie ClickHouse SQL-Anweisungen ausführen können, um beispielsweise folgende Aktionen auszuführen:

      • Erstellen, Aktualisieren und Löschen von Datenbanken, Tabellen, Indizes, Partitionen und Ansichten.

      • Ausführen von Abfragen zum Abrufen von Daten, die optional mit verschiedenen Bedingungen gefiltert und gruppiert werden.

      In diesem Schritt erstellen Sie mit dem ClickHouse-Client, der bereit für die Eingabe von Daten ist, eine Datenbank und eine Tabelle. Für die Zwecke dieses Tutorials erstellen Sie eine Datenbank namens test und erzeugen darin eine Tabelle namens visits, die die Länge von Websitebesuchen verfolgt.

      Da Sie sich in der Eingabeaufforderung von ClickHouse befinden, erstellen Sie nun Ihre Datenbank test durch Ausführung von:

      Sie sehen die folgende Ausgabe, die zeigt, dass Sie die Datenbank erstellt haben:

      Output

      CREATE DATABASE test Ok. 0 rows in set. Elapsed: 0.003 sec.

      Eine ClickHouse-Tabelle ähnelt Tabellen in anderen relationalen Datenbanken; sie enthält eine Sammlung verwandter Daten in einem strukturierten Format. Sie können Spalten zusammen mit ihren Typen festlegen, Datenzeilen hinzufügen und verschiedene Arten von Abfragen in Tabellen ausführen.

      Die Syntax zur Erstellung von Tabellen in ClickHouse folgt dieser Beispielstruktur:

      CREATE TABLE table_name
      (
          column_name1 column_type [options],
          column_name2 column_type [options],
          ...
      ) ENGINE = engine
      

      Die Werte table_name und column_name können beliebige gültige ASCII-Bezeichner sein. ClickHouse unterstützt eine breite Palette von Spaltentypen; einige der beliebtesten sind:

      • UInt64: dient der Speicherung von ganzzahligen Werten im Bereich 0 bis 18446744073709551615.

      • Float64: dient der Speicherung von Gleitkommazahlen wie 2039,23, 10,5 etc.

      • String: dient der Speicherung von Zeichen mit variabler Länge. Der Wert benötigt kein Attribut für maximale Länge, da er beliebige Längen speichern kann.

      • Date: dient der Speicherung von Daten, die dem Format YYYY-MM-DD folgen.

      • DateTime: dient der Speicherung von Daten, die die Uhrzeit umfassen und dem Format YYYY-MM-DD HH:MM:SS folgen.

      Nach den Spaltendefinitionen geben Sie die für die Tabelle verwendete Engine an. In ClickHouse bestimmen Engines über die physikalische Struktur der zugrunde liegenden Daten, die Abfragefunktionen der Tabelle, die gleichzeitigen Zugriffsmodi und die Unterstützung von Indizes. Verschiedene Engine-Typen eignen sich für verschiedene Anwendungsanforderungen. Der am häufigsten verwendete und weit verbreitete Engine-Typ ist MergeTree.

      Nachdem Sie sich einen Überblick über die Tabellenerstellung verschafft haben, erstellen Sie nun eine Tabelle. Beginnen Sie mit der Auswahl der Datenbank, die Sie ändern möchten:

      Sie sehen die folgende Ausgabe, die zeigt, dass Sie von der Datenbank default zur Datenbank test gewechselt sind:

      Output

      USE test Ok. 0 rows in set. Elapsed: 0.001 sec.

      Im Rest dieses Leitfadens wird davon ausgegangen, dass Sie Anweisungen im Kontext dieser Datenbank ausführen.

      Erstellen Sie Ihre Tabelle visits, indem Sie den folgenden Befehl ausführen:

      • CREATE TABLE visits (
      • id UInt64,
      • duration Float64,
      • url String,
      • created DateTime
      • ) ENGINE = MergeTree()
      • PRIMARY KEY id
      • ORDER BY id;

      Hier ist eine Aufstellung dessen, was der Befehl tut. Sie erstellen eine Tabelle namens visits, die vier Spalten aufweist:

      • id: Die Primärschlüsselspalte. Ähnlich wie bei anderen RDBMS-Systemen identifiziert eine Primärschlüsselspalte in ClickHouse eine Zeile eindeutig; jede Zeile muss einen eindeutigen Wert für diese Spalte aufweisen.

      • duration: Eine Gleitkommaspalte zur Speicherung der Dauer einzelner Besuche (in Sekunden). float-Spalten können Dezimalwerte wie 12,50 speichern.

      • url: Eine Zeichnfolgenspalte, die die besuchte URL speichert, wie z.B. http://example.com.

      • created: Eine Datums- und Uhrzeitspalte, die vefolgt, wann der Besuch stattgefunden hat.

      Nach den Spaltendefinitionen geben Sie MergeTree als Speicher-Engine für die Tabelle an. Die MergeTree-Familie von Engines wird aufgrund ihrer optimierten Unterstützung für große echtzeitbasierte Einfügungen, die allgemeine Stabilität sowie Unterstützung von Abfragen für Datenbanken empfohlen. Außerdem unterstützen MergeTree-Engines eine Sortierung von Zeilen nach Primärschlüssel, Partitionierung von Zeilen sowie Replikation und Abfrage von Daten.

      Wenn Sie ClickHouse zur Archivierung von Daten, die nicht oft abgefragt werden, oder zur Speicherung von temporären Daten verwenden möchten, können Sie die Log-Familie von Engines verwenden, um eine Optimierung für diesen Anwendungsfall vorzunehmen.

      Nach den Spaltendefinitionen definieren Sie andere Optionen auf der Tabellenebene. Die Klausel PRIMARY KEY legt id als Primärschlüsselspalte fest; die Klausel ORDER BY speichert anhand der Spalte id sortierte Werte. Ein Primärschlüssel identifiziert eine Zeile eindeutig und dient zum effizienten Zugreifen auf eine einzelne Zeile und ein effizientes Zuordnen von Zeilen.

      Bei Ausführung der Anweisung create sehen Sie folgende Ausgabe:

      Output

      CREATE TABLE visits ( id UInt64, duration Float64, url String, created DateTime ) ENGINE = MergeTree() PRIMARY KEY id ORDER BY id Ok. 0 rows in set. Elapsed: 0.010 sec.

      In diesem Abschnitt haben Sie eine Datenbank und eine Tabelle erstellt, um Daten zu Websitebesuchen zu verfolgen. Im nächsten Schritt fügen Sie Daten in die Tabelle ein, aktualisieren vorhandene Daten und löschen diese Daten.

      Schritt 4 — Einfügen, Aktualisieren und Löschen von Daten und Spalten

      In diesem Schritt verwenden Sie Ihre Tabelle namens visits, um Daten einzufügen, zu aktualisieren und zu löschen. Folgender Befehl ist ein Beispiel für die Syntax zur Eingabe von Zeilen in eine ClickHouse-Tabelle:

      INSERT INTO table_name VALUES (column_1_value, column_2_value, ....);
      

      Fügen Sie nun einige Zeilen von Beispieldaten zu Websitebesuchen in Ihre Tabelle visits ein, indem Sie nacheinander die folgenden Anweisungen ausführen:

      • INSERT INTO visits VALUES (1, 10.5, 'http://example.com', '2019-01-01 00:01:01');
      • INSERT INTO visits VALUES (2, 40.2, 'http://example1.com', '2019-01-03 10:01:01');
      • INSERT INTO visits VALUES (3, 13, 'http://example2.com', '2019-01-03 12:01:01');
      • INSERT INTO visits VALUES (4, 2, 'http://example3.com', '2019-01-04 02:01:01');

      Sie sehen die folgende Ausgabe, die für jede Einfügeanweisung wiederholt wird.

      Output

      INSERT INTO visits VALUES Ok. 1 rows in set. Elapsed: 0.004 sec.

      Die Ausgabe für die einzelnen Zeilen zeigt, dass Sie sie erfolgreich in die Tabelle visits eingefügt haben.

      Nun fügen Sie der Tabelle visits eine zusätzliche Spalte hinzu. Wenn Sie Spalten von bestehenden Tabellen hinzufügen oder löschen, unterstützt ClickHouse die Syntax ALTER.

      Die grundlegende Syntax für das Hinzufügen einer Spalte zu einer Tabelle lautet beispielsweise:

      ALTER TABLE table_name ADD COLUMN column_name column_type;
      

      Fügen Sie eine Spalte namens location hinzu, in der der Speicherort der Besuche auf einer Website gespeichert wird. Führen Sie dazu folgende Anweisung aus:

      • ALTER TABLE visits ADD COLUMN location String;

      Sie werden eine Ausgabe sehen, die der folgenden ähnelt:

      Output

      ALTER TABLE visits ADD COLUMN location String Ok. 0 rows in set. Elapsed: 0.014 sec.

      Die Ausgabe zeigt, dass Sie die Spalte location erfolgreich hinzugefügt haben.

      Ab Version 19.13.3 unterstützt ClickHouse aufgrund von Implementierungsbeschränkungen nicht mehr das Aktualisieren und Löschen einzelner Datenzeilen. ClickHouse unterstützt jedoch Massenaktualisierungen und -löschvorgänge und bietet eine eigene SQL-Syntax für diese Operationen, um ihre nicht standardmäßige Nutzung hervorzuheben.

      Die folgende Syntax ist ein Beispiel für eine Massenaktualisierung von Zeilen:

      ALTER TABLE table_name UPDATE  column_1 = value_1, column_2 = value_2 ...  WHERE  filter_conditions;
      

      Sie führen die folgende Anweisung aus, um die Spalte url aller Zeilen zu aktualisieren, die eine duration (Dauer) von weniger als 15 aufweisen. Geben Sie sie zur Ausführung in die Datenbankaufforderung ein:

      • ALTER TABLE visits UPDATE url = 'http://example2.com' WHERE duration < 15;

      Die Ausgabe der Anweisung zur Massenaktualisierung wird wie folgt aussehen:

      Output

      ALTER TABLE visits UPDATE url = 'http://example2.com' WHERE duration < 15 Ok. 0 rows in set. Elapsed: 0.003 sec.

      Die Ausgabe zeigt, dass Ihre Aktualisierungsanfrage erfolgreich abgeschlossen wurde. 0 rows in set in der Ausgabe weist darauf hin, dass die Abfrage keine Zeilen zurückgegeben hat; dies wird bei allen Aktualisierungs- und Löschabfragen der Fall sein.

      Die Beispielsyntax für das Massenlöschen von Zeilen ähnelt der Aktualisierung von Zeilen und weist die folgende Struktur auf:

      ALTER TABLE table_name DELETE WHERE filter_conditions;
      

      Um das Löschen von Daten zu testen, führen Sie folgende Anweisung aus, um alle Zeilen zu entfernen, die eine duration (Dauer) von weniger als 5 haben:

      • ALTER TABLE visits DELETE WHERE duration < 5;

      Die Ausgabe der Anweisung zur Massenlöschung wird in etwa folgendermaßen aussehen:

      Output

      ALTER TABLE visits DELETE WHERE duration < 5 Ok. 0 rows in set. Elapsed: 0.003 sec.

      Die Ausgabe bestätigt, dass Sie die Zeilen mit einer Dauer von weniger als fünf Sekunden gelöscht haben.

      Um Spalten aus Ihrer Tabelle zu löschen, würde die Syntax dieser Beispielstruktur folgen:

      ALTER TABLE table_name DROP COLUMN column_name;
      

      Löschen Sie die zuvor hinzugefügte Spalte location durch Ausführung von Folgendem:

      • ALTER TABLE visits DROP COLUMN location;

      Die Ausgabe von DROP COLUMN, die bestätigt, dass die Spalte gelöscht wurde, sieht wie folgt aus:

      Output

      ALTER TABLE visits DROP COLUMN location String Ok. 0 rows in set. Elapsed: 0.010 sec.

      Nachdem Sie Zeilen und Spalten in Ihrer Tabelle visits erfolgreich eingefügt, aktualisiert und gelöscht haben, fahren Sie nun im nächsten Schritt mit der Abfrage von Daten fort.

      Schritt 5 — Abfragen von Daten

      Die Abfragesprache von ClickHouse ist ein benutzerdefinierter SQL-Dialekt mit Erweiterungen und Funktionen, die für Analytics-Workloads geeignet sind. In diesem Schritt führen Sie Auswahl- und Aggregationsanfragen zum Abrufen von Daten und Ergebnissen aus Ihrer Tabelle namens visits aus.

      Auswahlabfragen ermöglichen es Ihnen, Zeilen und Spalten mit Daten, die nach den von Ihnen angegebenen Bedingungen gefiltert werden, zusammen mit Optionen wie Anzahl der zurückzugebenden Zeilen abzurufen. Mit der Syntax SELECT können Sie Zeilen und Spalten mit Daten auswählen. Die grundlegende Syntax für SELECT-Abfragen lautet:

      SELECT func_1(column_1), func_2(column_2) FROM table_name WHERE filter_conditions row_options;
      

      Führen Sie die folgende Anweisung aus, um url– und duration-Werte für Zeilen abzurufen, bei denen die URL http://example.com lautet.

      • SELECT url, duration FROM visits WHERE url = 'http://example2.com' LIMIT 2;

      Sie sehen den folgenden Output:

      Output

      SELECT url, duration FROM visits WHERE url = 'http://example2.com' LIMIT 2 ┌─url─────────────────┬─duration─┐ │ http://example2.com │ 10.5 │ └─────────────────────┴──────────┘ ┌─url─────────────────┬─duration─┐ │ http://example2.com │ 13 │ └─────────────────────┴──────────┘ 2 rows in set. Elapsed: 0.013 sec.

      Die Ausgabe hat zwei Zeilen zurückgegeben, die den von Ihnen angegebenen Bedingungen entsprechen. Nachdem Sie Werte ausgewählt haben, können Sie nun mit der Ausführung von Aggregationsabfragen fortfahren.

      Aggregationsabfragen stellen Abfragen dar, die auf einen Satz von Werten angewendet werden und einzelne Ausgabewerte zurückgeben. In Analysedatenbanken werden diese Abfragen häufig ausgeführt und von der Datenbank umfassend optimiert. Zu den Aggregatfunktionen, die von ClickHouse unterstützt werden, gehören:

      • count: gibt die Zahl der Zeilen zurück, die den angegebenen Bedingungen entsprechen.

      • sum: gibt die Summe der ausgewählten Spaltenwerte zurück.

      • avg: gibt den Durchschnitt der ausgewählten Spaltenwerte zurück.

      Zu ClickHouse-spezifischen Aggregatfunktionen gehören:

      • uniq: gibt eine ungefähre Zahl eindeutiger Zeilen zurück, die abgeglichen wurden.

      • topK: gibt mit einem Approximationsalgorithmus ein Array der häufigsten Werte einer bestimmten Spalte zurück.

      Um die Ausführung von Aggregationsabfragen zu testen, berechnen Sie die Gesamtdauer von Besuchen durch Ausführung der Abfrage sum:

      • SELECT SUM(duration) FROM visits;

      Sie werden eine Ausgabe ähnlich der Folgenden sehen:

      Output

      SELECT SUM(duration) FROM visits ┌─SUM(duration)─┐ │ 63.7 │ └───────────────┘ 1 rows in set. Elapsed: 0.010 sec.

      Berechnen Sie nun die führenden zwei URLs durch Ausführung von:

      • SELECT topK(2)(url) FROM visits;

      Sie werden eine Ausgabe ähnlich der Folgenden sehen:

      Output

      SELECT topK(2)(url) FROM visits ┌─topK(2)(url)──────────────────────────────────┐ │ ['http://example2.com','http://example1.com'] │ └───────────────────────────────────────────────┘ 1 rows in set. Elapsed: 0.010 sec.

      Nachdem Sie Ihre Tabelle visits erfolgreich abgefragt haben, löschen Sie nun im nächsten Schritt Tabellen und Datenbanken.

      Schritt 6 — Löschen von Tabellen und Datenbanken

      In diesem Abschnitt löschen Sie die Tabelle visits sowie die Datenbank test.

      Die Syntax zur Löschung von Tabellen folgt diesem Beispiel:

      DROP TABLE table_name;
      

      Um die Tabelle visits zu löschen, führen Sie folgende Anweisung aus:

      Die folgende Ausgabe zeigt an, dass die Tabelle erfolgreich gelöscht wurde:

      output

      DROP TABLE visits Ok. 0 rows in set. Elapsed: 0.005 sec.

      Mit der Syntax DROP database table_name können Sie Datenbanken löschen. Um die Datenbank namens test zu löschen, führen Sie folgende Anweisung aus:

      Die resultierende Ausgabe zeigt, dass die Datenbank erfolgreich gelöscht wurde.

      Output

      DROP DATABASE test Ok. 0 rows in set. Elapsed: 0.003 sec.

      In diesem Schritt haben Sie Tabellen und Datenbanken gelöscht. Nachdem Sie Datenbanken, Tabellen und Daten in Ihrer ClickHouse-Instanz erstellt, aktualisiert und gelöscht haben, aktivieren Sie nun im nächsten Abschnitt den Remotezugriff auf Ihren Datenbankserver.

      Schritt 7 — Einrichten von Firewall-Regeln (optional)

      Wenn Sie ClickHouse nur lokal verwenden möchten (mit auf dem gleichen Server ausgeführten Anwendungen) oder auf Ihrem Server keine Firewall aktiviert haben, müssen Sie diesen Abschnitt nicht beachten. Wenn Sie hingegen eine Remoteverbindung mit dem ClickHouse-Datenbankserver herstellen möchten, sollten Sie diesen Schritt durchführen.

      Auf Ihrem Server ist derzeit eine Firewall aktiviert, die es Ihrer öffentlichen IP-Adresse verbietet, auf alle Ports zuzugreifen. Führen Sie die folgenden beiden Schritte durch, um Remotezugriff zu aktivieren:

      • Ändern Sie die Konfiguration von ClickHouse und erlauben Sie es der Software, alle Schnittstellen abzuhören.

      • Fügen Sie eine Firewall-Regel hinzu, die eingehende Verbindungen zu Port 8123 zulässt. Dabei handelt es sich um den HTTP-Port, an dem der ClickHouse-Server ausgeführt wird.

      Wenn Sie sich in der Datenbankaufforderung befinden, beenden Sie sie durch Eingabe von Strg+D.

      Bearbeiten Sie die Konfigurationsdatei, indem Sie Folgendes ausführen:

      • sudo nano /etc/clickhouse-server/config.xml

      Heben Sie dann die Auskommentierung der Zeile mit <!-- <listen_host>0.0.0.0</listen_host> --> auf, wie in der folgenden Datei dargestellt:

      /etc/clickhouse-server/config.xml

      ...
       <interserver_http_host>example.yandex.ru</interserver_http_host>
          -->
      
          <!-- Listen specified host. use :: (wildcard IPv6 address), if you want to accept connections both with IPv4 and IPv6 from everywhere. -->
          <!-- <listen_host>::</listen_host> -->
          <!-- Same for hosts with disabled ipv6: -->
          <listen_host>0.0.0.0</listen_host>
      
          <!-- Default values - try listen localhost on ipv4 and ipv6: -->
          <!--
          <listen_host>::1</listen_host>
          <listen_host>127.0.0.1</listen_host>
          -->
      ...
      

      Speichern Sie die Datei und schließen Sie sie. Starten Sie zum Anwenden der neuen Konfiguration den Dienst neu, indem Sie Folgendes ausführen:

      • sudo service clickhouse-server restart

      Bei diesem Befehl werden Sie keine Ausgabe sehen. Der ClickHouse-Server lauscht an Port 8123 nach HTTP-Verbindungen und an Port 9000 nach Verbindungen von clickhouse-client. Aktivieren Sie mit dem folgenden Befehl Zugriff an beiden Ports für die IP-Adresse Ihres zweiten Servers:

      • sudo ufw allow from second_server_ip/32 to any port 8123
      • sudo ufw allow from second_server_ip/32 to any port 9000

      Für beide Befehle wird die folgende Ausgabe angezeigt, die bestätigt, dass Sie den Zugriff auf beide Ports aktiviert haben:

      Output

      Rule added

      ClickHouse wird nun über die von Ihnen hinzugefügte IP-Adresse zugänglich sein. Fügen Sie bei Bedarf zusätzliche IP-Adressen hinzu, z. B. die Adresse Ihres lokalen Rechners.

      Um zu überprüfen, ob Sie sich über den Remotecomputer mit dem ClickHouse-Server verbinden können, führen Sie zunächst die Schritte in Schritt 1 dieses Tutorials auf dem zweiten Server aus und stellen Sie sicher, dass Sie den clickhouse-client installiert haben.

      Nachdem Sie sich beim zweiten Server angemeldet haben, starten Sie nun eine Client-Sitzung, indem Sie Folgendes ausführen:

      • clickhouse-client --host your_server_ip --password

      Ihnen wird die folgende Ausgabe angezeigt, die bestätigt, dass Sie erfolgreich eine Verbindung zum Server hergestellt haben:

      Output

      ClickHouse client version 19.13.3.26 (official build). Password for user (default): Connecting to your_server_ip:9000 as user default. Connected to ClickHouse server version 19.13.3 revision 54425. hostname :)

      In diesem Schritt haben Sie Remotezugriff auf Ihren ClickHouse-Datenbankserver aktiviert, indem Sie Ihre Firewall-Regeln angepasst haben.

      Zusammenfassung

      Sie haben auf Ihrem Server erfolgreich eine ClickHouse-Datenbank eingerichtet sowie eine Datenbank und Tabelle erstellt, Daten hinzugefügt, Abfragen ausgeführt und die Datenbank gelöscht. In der Dokumentation von ClickHouse können Sie mehr über die Benchmarks der Software im Vergleich zu anderen Open-Source- und kommerziellen Analysedatenbanken erfahren sowie allgemeine Referenzdokumente lesen.

      Zu weiteren Funktionen von ClickHouse gehört eine auf mehrere Server verteilte Abfrageverarbeitung, die für mehr Leistung und Schutz vor Datenverlusten sorgt, indem Daten in verschiedenen Shards gespeichert werden.



      Source link