One place for hosting & domains

      Bereitstellen von Laravel 7 und MySQL in Kubernetes mithilfe von Helm


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

      Einführung

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

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

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

      Voraussetzungen

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

      Schritt 1 — Erstellen einer neuen Laravel-Anwendung

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

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

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

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

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

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

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

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

      ./resources/views/welcome.blade.php

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

      Speichern und schließen Sie die Datei.

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

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

      Schritt 2 — Containerisieren Ihrer Laravel-Anwendung

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

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

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

      ./Dockerfile

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

      Speichern und schließen Sie die Datei.

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

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

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

      • nano ./docker-entrypoint.sh

      Fügen Sie nun folgendes Skript hinzu:

      ./docker-entrypoint.sh

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

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

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

      ./.dockerignore

      .env
      /vendor
      

      Speichern und schließen Sie die Datei.

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

      Sie werden eine Ausgabe wie diese sehen:

      Output

      APP_KEY=base64:0EHhVpgg ... UjGE=

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

      • nano ./docker-compose.yml

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

      ./docker-compose.yml

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

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

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

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

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

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

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

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

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

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

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

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

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

      Schritt 3 — Pushen Ihres Docker-Image an Docker Hub

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

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

      Erstellen eines neuen Repository in Docker Hub

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

      • docker login -u your_docker_hub_username

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

      Abschließend pushen Sie Ihr Image an Docker Hub:

      • docker push your_docker_hub_username/laravel-kubernetes:latest

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

      Output

      latest: digest: sha256:df4bdeda91484c8c26a989b13b8f27ab14d93ab2e676e3c396714cb3811c4086 size: 4918

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

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

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

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

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

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

      ./helm/values.yml

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

      Speichern und schließen Sie die Datei.

      Erstellen Sie nun eine Datei namens secrets.yml:

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

      ./helm/secrets.yml

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

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

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

      Speichern und schließen Sie secrets.yml.

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

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

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

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

      Sie werden eine Ausgabe wie diese sehen:

      Output

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

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

      Suchen Sie nach dem Namen Ihrer Anwendung:

      Output

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

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

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

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

      • helm delete laravel-kubernetes

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

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

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

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

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

      Fügen Sie jetzt die folgenden Zeilen hinzu:

      ./helm/values.yml

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

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

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

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

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

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

      Nach der Installation werden Sie eine Ausgabe wie diese sehen:

      Output

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

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

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

      ./ingress.yml

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

      Speichern und schließen Sie die Datei.

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

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

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

      Output

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

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

      • kubectl create namespace cert-manager

      Sie sehen diese Ausgabe:

      Output

      namespace/cert-manager created

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

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

      Bei erfolgreicher Ergänzung erhalten Sie folgende Ausgabe:

      Output

      "jetstack" has been added to your repositories

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

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

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

      Output

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

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

      • nano ./production_issuer.yml

      Fügen Sie nun Folgendes hinzu:

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

      Speichern und schließen Sie die Datei.

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

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

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

      • kubectl get service nginx-ingress-controller

      Output

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

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

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

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

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

      Schritt 6 — Ausführen von Remotebefehlen

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

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

      Sie werden eine Ausgabe wie diese sehen:

      Output

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

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

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

      Dieser Befehl wird eine Ausgabe erzeugen:

      Output

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

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

      Zusammenfassung

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

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



      Source link

      Installieren von Jenkins unter Ubuntu 20.04


      Einführung

      Wenn es um die Bewältigung sich wiederholender technischer Aufgaben geht, ist es nicht immer einfach, gute Automatisierungslösungen zu finden. Mit Jenkins, einem Open-Source-basierten Automatisierungsserver, können Sie Aufgaben von der Erstellung bis zur Bereitstellung von Software effizient verwalten. Jenkins ist Java-basiert und wird aus Ubuntu-Paketen bzw. durch Herunterladen und Ausführen der entsprechenden WAR-Datei (Web Application Archive) installiert: Dabei handelt es sich um eine Sammlung von Dateien, die eine vollständige Webanwendung ergeben, die sich auf einem Server ausführen lässt.

      In diesem Tutorial installieren wir Jenkins unter Ubuntu 20.04, starten den Entwicklungsserver und erstellen einen Administratorbenutzer, sodass Sie damit beginnen können, die Möglichkeiten von Jenkins zu erkunden. Zwar verfügen Sie nach Abschluss dieses Tutorials über einen einsatzbereiten Entwicklungsserver, doch sollten Sie ihn für die Produktion noch sichern. Folgen Sie dazu dem Tutorial Konfigurieren von Jenkins mit SSL unter Verwendung eines Nginx-Reverseproxy unter Ubuntu 18.04.

      Voraussetzungen

      Um dieser Anleitung zu folgen, benötigen Sie:

      Schritt 1 — Installieren von Jenkins

      Die Version von Jenkins, die in den standardmäßigen Ubuntu-Paketen enthalten ist, ist oft älter als die neueste verfügbare Version des Projekts selbst. Um sicherzustellen, dass Sie über die neuesten Korrekturen und Funktionen verfügen, verwenden Sie die vom Projekt gepflegten Pakete zur Installation von Jenkins.

      Fügen Sie zunächst den Repository-Schlüssel zum System hinzu:

      • wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -

      Nach dem Hinzufügen des Schlüssels gibt das System OK zurück.

      Als Nächstes fügen wir die Adresse für das Debian-Paket-Repository in die sources.list des Servers ein:

      • sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'

      Nach Eingabe beider Befehle werden wir update ausführen, damit apt das neue Repository nutzt.

      Schließlich installieren wir Jenkins und seine Abhängigkeiten.

      Nachdem Jenkins und seine Abhängigkeiten vorhanden sind, starten wir nun den Jenkins-Server.

      Schritt 2 — Starten von Jenkins

      Starten wir Jenkins durch Verwendung von systemctl:

      sudo systemctl start jenkins
      

      Da systemctl keine Statusausgabe anzeigt, nutzen wir den status-Befehl zum Überprüfen, ob Jenkins erfolgreich gestartet wurde:

      • sudo systemctl status jenkins

      Wenn alles geklappt hat, zeigt der Anfang der Statusausgabe an, dass der Dienst aktiv und so konfiguriert ist, dass er beim Booten gestartet wird:

      Output

      ● jenkins.service - LSB: Start Jenkins at boot time Loaded: loaded (/etc/init.d/jenkins; generated) Active: active (exited) since Fri 2020-06-05 21:21:46 UTC; 45s ago Docs: man:systemd-sysv-generator(8) Tasks: 0 (limit: 1137) CGroup: /system.slice/jenkins.service

      Nachdem Jenkins ausgeführt wird, sollten wir nun unsere Firewall-Regeln so anpassen, dass wir den Server über einen Webbrowser erreichen können. Damit ist die Ersteinrichtung abgeschlossen.

      Schritt 3 — Öffnen der Firewall

      Um eine UFW-Firewall einzurichten, konsultieren Sie Ersteinrichtung des Servers mit Ubuntu 20.04, Schritt 4 — Einrichten einer einfachen Firewall. Standardmäßig wird Jenkins an Port 8080 ausgeführt. Wir öffnen diesen Port mit ufw:

      Anmerkung: Wenn die Firewall inaktiv ist, können Sie mit folgenden Befehlen OpenSSH zulassen und die Firewall aktivieren:

      • sudo ufw allow OpenSSH
      • sudo ufw enable

      Überprüfen Sie zum Bestätigen der neuen Regeln den Status von ufw:

      Sie werden feststellen, dass Datenverkehr an Port 8080 von überall zugelassen ist:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 8080 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 8080 (v6) ALLOW Anywhere (v6)

      Nach der Installation von Jenkins und der Konfiguration unserer Firewall können wir die Installationsphase abschließen und mit der Einrichtung von Jenkins beginnen.

      Schritt 4 — Einrichten von Jenkins

      Um Ihre Installation einzurichten, rufen Sie Jenkins an seinem Standardport 8080 auf, indem Sie den Domänennamen oder die IP-Adresse Ihres Servers verwenden: http://your_server_ip_or_domain:8080

      Sie sollten den Bildschirm Unlock Jenkins (Jenkins entsperren) erhalten, in dem der Speicherort des ersten Passworts angezeigt wird:

      Bildschirm „Unlock Jenkins“ (Jenkins entsperren)

      Verwenden Sie im Terminalfenster den Befehl cat zum Anzeigen des Passworts:

      • sudo cat /var/lib/jenkins/secrets/initialAdminPassword

      Kopieren Sie das 32 Zeichen lange alphanumerische Passwort aus dem Terminal und fügen Sie es in das Feld Administrator password (Administratorkennwort) ein. Klicken Sie dann auf Continue (Weiter).

      Im nächsten Bildschirm wird die Option zum Installieren empfohlener Plugins oder Auszuwählen spezifischer Plugins angezeigt:

      Bildschirm „Customize Jenkins“ (Jenkins anpassen)

      Wir klicken auf die Option Install suggested plugins (Empfohlene Plugins installieren), woraufhin der Installationsprozess unmittelbar beginnt.

      Bildschirm „Jenkins Getting Started Install Plugins“ (Erste Schritte mit Jenkins — Plugins installieren)

      Nach Abschluss der Installation werden Sie aufgefordert, den ersten Administratorbenutzer einzurichten. Es ist möglich, diesen Schritt überspringen und als admin mit dem oben verwendeten ursprünglichen Passwort fortzufahren, aber wir werden uns einen Moment Zeit nehmen, um den Benutzer zu erstellen.

      Anmerkung: Der standardmäßige Jenkins-Server ist NICHT verschlüsselt, sodass die mit diesem Formular übermittelten Daten nicht geschützt sind. Siehe Konfigurieren von Jenkins mit SSL unter Verwendung eines Nginx-Reverseproxy unter Ubuntu 20.04, um Anmeldedaten von Benutzern und Informationen über Builds, die über die Weboberfläche übertragen werden, zu schützen.

      Bildschirm „Jenkins Create First Admin User“ (Erstellen des ersten Administratorbenutzers in Jenkins)

      Geben Sie den Namen und das Passwort für Ihren Benutzer ein:

      Jenkins Create User (Jenkins: Benutzer erstellen)

      Sie sehen eine Seite zur Instance Configuration (Instanzkonfiguration), auf der Sie dazu aufgefordert werden, die bevorzugte URL für Ihre Jenkins-Instanz zu bestätigen. Bestätigen Sie entweder den Domänennamen für Ihren Server bzw. die IP-Adresse Ihres Servers:

      Jenkins Instance Configuration (Jenkins: Instanzkonfiguration)

      Nach der Bestätigung der entsprechenden Daten klicken Sie auf Save and Finish (Speichern und Fertigstellen). Sie erhalten eine Seite mit der Bestätigung, dass „Jenkins is Ready!“ (Jenkins bereit ist):

      Bildschirm „Jenkins is ready“ (Jenkins ist bereit)

      Klicken Sie auf Start using Jenkins (Mit Verwendung von Jenkins beginnen), um das Haupt-Dashboard von Jenkins aufzurufen:

      Bildschirm „Welcome to Jenkins“ (Willkommen bei Jenkins)

      Jetzt haben Sie die Installation von Jenkins erfolgreich abgeschlossen.

      Zusammenfassung

      In diesem Tutorial haben Sie Jenkins mit den vom Projekt bereitgestellten Paketen installiert, den Server gestartet, die Firewall geöffnet und einen Administratorbenutzer erstellt. Nun können Sie mit der Erkundung von Jenkins beginnen.

      Folgen Sie danach Abschluss dem Leitfaden Konfigurieren von Jenkins mit SSL unter Verwendung eines Nginx-Reverseproxy unter Ubuntu 20.04, um Ihre Passwörter sowie sensible System- oder Produktdaten, die zwischen dem Computer und dem Server in Klartext übertragen werden, zu schützen. Anschließend können Sie Jenkins weiter nutzen.

      Um mehr über die Funktionen von Jenkins zu erfahren, lesen Sie weitere Tutorials zu dem Thema:



      Source link

      Installieren und Konfigurieren von Postfix unter Ubuntu 20.04


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

      Einführung

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

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

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

      Voraussetzungen

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

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

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

      Schritt 1 — Installieren von Postfix

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

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

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

      • sudo DEBIAN_PRIORITY=low apt install postfix

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

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

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

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

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

      • sudo dpkg-reconfigure postfix

      Die Eingabeaufforderungen werden mit Ihren vorherigen Antworten vorausgefüllt.

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

      Schritt 2 — Ändern der Postfix-Konfiguration

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

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

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

      • sudo postconf -e 'home_mailbox= Maildir/'

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

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

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

      • sudo nano /etc/postfix/virtual

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

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

      /etc/postfix/virtual

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

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

      Wenden Sie die Zuordnung durch die folgende Eingabe an:

      • sudo postmap /etc/postfix/virtual

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

      • sudo systemctl restart postfix

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      /etc/s-nail.rc

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

      Diese Zeilen bewirken Folgendes:

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

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

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

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

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

      Anmerkung: Sie erhalten möglicherweise die folgende Antwort:

      Output

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

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

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

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

      Output

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

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

      Schritt 5 – Testen des Clients

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

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

      Output

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

      Drücken Sie ENTER, um die Nachricht anzuzeigen:

      Output

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

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

      Output

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

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

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

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

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

      Beginnen Sie mit dem Schreiben einer Testnachricht in einem Texteditor:

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

      ~/test_message

      Hello,
      
      This is a test.  Please confirm receipt!
      

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

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

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

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

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

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

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

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

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

      Die Ausgabe sieht dann so aus:

      Output

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

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

      Zusammenfassung

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



      Source link