One place for hosting & domains

      Schnellstart

      Erstellen eines Hashicorp-Vault-Servers mit Packer und Terraform in DigitalOcean [Schnellstart]


      Einführung

      Vault von Hashicorp ist ein Open-Source-Tool, um Geheimnisse und sensible Daten in dynamischen Cloud-Umgebungen sicher zu speichern. Packer und Terraform, ebenfalls von Hashicorp entwickelt, können zusammen verwendet werden, um Images von Vault zu kreieren und bereitzustellen.

      In diesem Tutorial erstellen Sie mit Packer einen unveränderlichen Snapshot des Systems mit installiertem Vault und dirigieren dessen Bereitstellung mit Terraform.

      Eine ausführlichere Version dieses Tutorials finden Sie in Erstellen eines Hashicorp Vault-Servers mit Packer und Terraform in DigitalOcean.

      Voraussetzungen

      • Auf Ihrem lokalen Rechner installierter Packer. Lesen Sie für Anweisungen die offizielle Dokumentation.
      • Auf Ihrem lokalen Rechner installiertes Terraform. Lesen Sie die offizielle Dokumentation für eine Anleitung.
      • Ein persönliches Zugriffstoken (API-Schlüssel) mit Lese- und Schreibberechtigungen für Ihr DigitalOcean-Konto. Besuchen Sie Erstellen eines persönlichen Zugriffstokens, um ein Token zu erstellen.
      • Einen SSH-Schlüssel, den Sie zur Authentifizierung mit den bereitgestellten Vault Droplets verwenden, die auf Ihrem lokalen Rechner verfügbar sind und Ihrem DigitalOcean-Konto hinzugefügt werden. Sie benötigen auch dessen Fingerabdruck, den Sie von der Security-Seite Ihres Kontos nach dem Erstellen kopieren können. Besuchen Sie die DigitalOcean-Dokumentation für detaillierte Anweisungen oder das Tutorial Einrichten von SSH-Schlüsseln.

      Schritt 1 — Erstellen einer Packer-Vorlage

      Erstellen und wechseln Sie in das Verzeichnis ~/vault-orchestration, um Ihre Vault-Dateien zu speichern:

      • mkdir ~/vault-orchestration
      • cd ~/vault-orchestration

      Erstellen Sie separate Verzeichnisse für die Packer- und Terraform-Konfiguration, indem Sie Folgendes ausführen:

      Navigieren Sie zum Verzeichnis Packer:

      Verwenden von Vorlagenvariablen

      Erstellen Sie eine variables.json in Ihrem packer-Unterverzeichnis, um Ihre privaten variablen Daten zu speichern:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/packer/variables.json

      {
        "do_token": "your_do_api_key",
        "base_system_image": "ubuntu-18-04-x64",
        "region": "nyc3",
        "size": "s-1vcpu-1gb"
      }
      

      Sie verwenden diese Variablen in der Vorlage, die Sie erstellen. Sie können die Werte Basisbild, Region und Droplet-Größe entsprechend den developer docs bearbeiten.

      Ersetzen Sie your_do_api_key durch Ihren API-Schlüssel. Speichern und schließen Sie dann die Datei.

      Erstellen von Builders und Provisioners

      Erstellen Sie Ihre Packer-Vorlage für Vault in einer Datei namens template.json:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/packer/template.json

      {
         "builders": [{
             "type": "digitalocean",
             "api_token": "{{user `do_token`}}",
             "image": "{{user `base_system_image`}}",
             "region": "{{user `region`}}",
             "size": "{{user `size`}}",
             "ssh_username": "root"
         }],
         "provisioners": [{
             "type": "shell",
             "inline": [
                 "sleep 30",
                 "sudo apt-get update",
                 "sudo apt-get install unzip -y",
                 "curl -L https://releases.hashicorp.com/vault/1.3.2/vault_1.3.2_linux_amd64.zip -o vault.zip",
                 "unzip vault.zip",
                 "sudo chown root:root vault",
                 "mv vault /usr/local/bin/",
                 "rm -f vault.zip"
             ]
      }]
      }
      

      Sie definieren einen einfachen digitalocean-Builder. Packer erstellt ein temporäres Droplet der definierten Größe, des definierten Bilds und der definierten Region, wobei der bereitgestellte API-Schlüssel verwendet wird.

      Der Provisioner stellt über SSH eine Verbindung mit dem angegebenen Benutzernamen her und führt nacheinander alle definierten Provisioners aus, bevor ein DigitalOcean-Snapshot aus dem Droplet erstellt und gelöscht wird.

      Es ist eine Art Shell, die die angegebenen Befehle auf das Ziel ausführt. Die Befehle in der Vorlage warten 30 Sekunden, bis das System hochgefahren ist. Anschließend wird Vault 1.3.2 heruntergeladen und entpackt. Konsultieren Sie die offizielle Vault-Downloadseite, um die aktuellste Version für Linux zu erhalten.

      Speichern und schließen Sie die Datei.

      Überprüfen Sie die Gültigkeit Ihrer Vorlage:

      • packer validate -var-file=variables.json template.json

      Sie sehen die folgende Ausgabe:

      Output

      Template validated successfully.

      Schritt 2 — Erstellen des Snapshots

      Erstellen Sie Ihren Snapshot mit dem Packer-Befehl build:

      • packer build -var-file=variables.json template.json

      Sie sehen eine Menge Ausgabe, die so aussehen wird:

      Output

      digitalocean: output will be in this color. ==> digitalocean: Creating temporary ssh key for droplet... ==> digitalocean: Creating droplet... ==> digitalocean: Waiting for droplet to become active... ==> digitalocean: Using ssh communicator to connect: ... ==> digitalocean: Waiting for SSH to become available... ==> digitalocean: Connected to SSH! ==> digitalocean: Provisioning with shell script: /tmp/packer-shell035430322 ... ==> digitalocean: % Total % Received % Xferd Average Speed Time Time Time Current ==> digitalocean: Dload Upload Total Spent Left Speed digitalocean: Archive: vault.zip ==> digitalocean: 100 45.5M 100 45.5M 0 0 154M 0 --:--:-- --:--:-- --:--:-- 153M digitalocean: inflating: vault ==> digitalocean: Gracefully shutting down droplet... ==> digitalocean: Creating snapshot: packer-1581537927 ==> digitalocean: Waiting for snapshot to complete... ==> digitalocean: Destroying droplet... ==> digitalocean: Deleting temporary ssh key... Build 'digitalocean' finished. ==> Builds finished. The artifacts of successful builds are: --> digitalocean: A snapshot was created: 'packer-1581537927' (ID: 58230938) in regions '...'

      Die letzte Zeile enthält den Namen des Snapshots (wie packer-1581537927) und seine ID in Klammern, wie hier hervorgehoben. Notieren Sie sich die ID des Snapshots, da Sie diese im nächsten Schritt benötigen.

      Falls der Build-Prozess durch Fehler in der API fehlschlägt, warten Sie einige Minuten und versuchen Sie es dann erneut.

      Schritt 3 — Schreiben der Terraform-Konfiguration

      Navigieren Sie zum Unterverzeichnis terraform:

      • cd ~/vault-orchestration/terraform

      Erstellen Sie eine Datei namens do-provider.tf, um den Provider zu speichern:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/terraform/do-provider.tf

      variable "do_token" {
      }
      
      variable "ssh_fingerprint" {
      }
      
      variable "instance_count" {
      default = "1"
      }
      
      variable "do_snapshot_id" {
      }
      
      variable "do_name" {
      default = "vault"
      }
      
      variable "do_region" {
      }
      
      variable "do_size" {
      }
      
      variable "do_private_networking" {
      default = true
      }
      
      provider "digitalocean" {
      token = var.do_token
      }
      

      Diese Datei stellt dem digitalocean-Provider einen API-Schlüssel zur Verfügung. Um die Werte dieser Variablen anzugeben, erstellen Sie eine Variablendefinitionsdatei, ähnlich wie bei Packer. Der Dateiname muss entweder auf .tfvars oder auf .tfvars.json enden.

      Speichern und schließen Sie die Datei.

      Erstellen Sie eine Variablendefinitionsdatei:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/terraform/definitions.tf

      do_token         = "your_do_api_key"
      ssh_fingerprint  = "your_ssh_key_fingerprint"
      do_snapshot_id   = your_do_snapshot_id
      do_name          = "vault"
      do_region        = "nyc3"
      do_size          = "s-1vcpu-1gb"
      instance_count   = 1
      

      Ersetzen Sie your_do_api_key, your_ssh_key_fingerprint und your_do_snapshot_id (die Snapshot-ID, die Sie im vorherigen Schritt notiert haben). Die Parameter do_region und do_size müssen die gleichen Werte wie in der Packer-Variablendatei haben.

      Speichern und schließen Sie die Datei.

      Erstellen Sie die folgende Datei, um die Bereitstellungskonfiguration des Vault-Snapshots zu speichern:

      Fügen Sie die folgenden Zeilen hinzu:

      ~/vault-orchestration/terraform/deployment.tf

      resource "digitalocean_droplet" "vault" {
      count              = var.instance_count
      image              = var.do_snapshot_id
      name               = var.do_name
      region             = var.do_region
      size               = var.do_size
      private_networking = var.do_private_networking
      ssh_keys = [
        var.ssh_fingerprint
      ]
      }
      
      output "instance_ip_addr" {
      value = {
        for instance in digitalocean_droplet.vault:
        instance.id => instance.ipv4_address
      }
      description = "The IP addresses of the deployed instances, paired with their IDs."
      }
      

      Sie definieren eine einzelne resource vom Typ digitalocean_droplet namens vault. Sie legen ihre Parameter entsprechend den Variablenwerten fest und fügen (mit seinem Fingerabdruck) einen SSH-Schlüssel von Ihrem DigitalOcean-Konto zur Droplet-Ressource hinzu. Sie output die IP-Adressen aller neu erstellten Instanzen an die Konsole aus.

      Speichern und schließen Sie die Datei.

      Initialisieren Sie das Verzeichnis als Terraform-Projekt:

      Sie sehen die folgende Ausgabe:

      Output

      Initializing the backend... Initializing provider plugins... The following providers do not have any version constraints in configuration, so the latest version was installed. To prevent automatic upgrades to new major versions that may contain breaking changes, it is recommended to add version = "..." constraints to the corresponding provider blocks in configuration, with the constraint strings suggested below. * provider.digitalocean: version = "~> 1.14" Terraform has been successfully initialized! You may now begin working with Terraform. Try running "terraform plan" to see any changes that are required for your infrastructure. All Terraform commands should now work. If you ever set or change modules or backend configuration for Terraform, rerun this command to reinitialize your working directory. If you forget, other commands will detect it and remind you to do so if necessary.

      Schritt 4 — Bereitstellung von Vault mit Terraform

      Testen Sie die Gültigkeit Ihrer Konfiguration:

      Sie sehen die folgende Ausgabe:

      Output

      Success! The configuration is valid.

      Führen Sie den Befehl plan aus, um zu sehen, was Terraform bei der Bereitstellung der Infrastruktur versucht:

      • terraform plan -var-file="definitions.tfvars"

      Die Ausgabe wird ähnlich sein wie:

      Output

      Refreshing Terraform state in-memory prior to plan... The refreshed state will be used to calculate this plan, but will not be persisted to local or remote state storage. ------------------------------------------------------------------------ An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: # digitalocean_droplet.vault[0] will be created + resource "digitalocean_droplet" "vault" { ... } Plan: 1 to add, 0 to change, 0 to destroy. ------------------------------------------------------------------------ Note: You didn't specify an "-out" parameter to save this plan, so Terraform can't guarantee that exactly these actions will be performed if "terraform apply" is subsequently run.

      Führen Sie den Plan aus:

      • terraform apply -var-file="definitions.tfvars"

      Das Droplet wird die Bereitstellung abschließen und Sie sehen eine Ausgabe, die etwa folgendermaßen aussieht:

      Output

      An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: + digitalocean_droplet.vault-droplet ... Plan: 1 to add, 0 to change, 0 to destroy. ... digitalocean_droplet.vault-droplet: Creating... ... Apply complete! Resources: 1 added, 0 changed, 0 destroyed. Outputs: instance_ip_addr = { "181254240" = "your_new_server_ip" }

      Schritt 5 — Verifizieren Ihres bereitgestellten Droplet

      Führen Sie Folgendes aus, um sich mit Ihrem neuen Droplet zu verbinden:

      Nach der Anmeldung führen Sie Vault aus mit:

      Sie sehen die entsprechende “Hilfe”-Ausgabe:

      Output

      Usage: vault <command> [args] Common commands: read Read data and retrieves secrets write Write data, configuration, and secrets delete Delete secrets and configuration list List data or secrets login Authenticate locally agent Start a Vault agent server Start a Vault server status Print seal and HA status unwrap Unwrap a wrapped secret Other commands: audit Interact with audit devices auth Interact with auth methods debug Runs the debug command kv Interact with Vault's Key-Value storage lease Interact with leases namespace Interact with namespaces operator Perform operator-specific tasks path-help Retrieve API help for paths plugin Interact with Vault plugins and catalog policy Interact with policies print Prints runtime configurations secrets Interact with secrets engines ssh Initiate an SSH session token Interact with tokens

      Zusammenfassung

      Sie verfügen jetzt über ein automatisiertes System zur Bereitstellung von Hashicorp Vault auf DigitalOcean Droplets mit Unterstützung von Terraform und Packer. Um Vault zu verwenden, müssen Sie es initialisieren und weiter konfigurieren. Anweisungen hierzu finden Sie in den Offiziellen Dokumenten.

      Weitere Tutorials zur Verwendung von Terraform finden Sie auf der Terraform Content Page.



      Source link

      So installieren Sie Linux, Nginx, MySQL, PHP (LEMP) Stack unter CentOS 8 [Schnellstart]


      Einführung

      In diesem Tutorial installieren Sie einen LEMP-Stack auf einem CentOS 8-Server. Obwohl MySQL über die Standard-Repositorys in CentOS 8 verfügbar ist, beschreibt dieser Leitfaden den Prozess der Einrichtung eines LEMP-Stacks mit MariaDB als Datenbank-Management-System.

      Eine detailliertere Version dieses Tutorials mit weiteren Erklärungen zu jedem Schritt finden Sie unter So installieren Sie Linux, Nginx, MySQL, PHP (LEMP) Stack unter CentOS 8.

      Voraussetzungen

      Um diesem Leitfaden zu folgen, müssen Sie auf einen CentOS-8-Server als sudo-Benutzer zugreifen.

      Schritt 1 – Installation von Nginx

      Installieren Sie das nginx-Paket mit:

      Wenn die Installation abgeschlossen ist, müssen Sie den folgenden Befehl ausführen, um den Server zu aktivieren und zu starten:

      • sudo systemctl start nginx

      Wenn firewalld aktiv ist, müssen Sie den folgenden Befehl ausführen, um den externen Zugriff auf Port 80 (HTTP) zu gestatten:

      • sudo firewall-cmd --permanent --add-service=http

      Laden Sie die Firewall-Konfiguration neu, damit die Änderungen wirksam werden:

      • sudo firewall-cmd --reload

      Nachdem die neue Firewall-Regel hinzugefügt wurde, können Sie testen, ob der Server läuft, indem Sie auf die öffentliche IP-Adresse des Servers oder den Domänennamen von Ihrem Web-Browser aus zugreifen. Sie sehen in etwa folgende Seite:

      Standard Nginx Page CentOS 8

      Schritt 2 – Installation von MariaDB

      Wir installieren jetzt MariaDB, eine gemeinschaftlich entwickelte Kopie des Original-MySQL-Servers von Oracle. Um diese Software zu installieren, führen Sie Folgendes aus:

      • sudo dnf install mariadb-server

      Wenn die Installation abgeschlossen ist, aktivieren und starten Sie den MariaDB-Server mit:

      • sudo systemctl start mariadb

      Um die Sicherheit Ihres Datenbank-Servers zu verbessern, wird empfohlen, ein Sicherheitsskript auszuführen, in das MariaDB bereits vorinstalliert ist. Starten Sie das interaktive Skript mit:

      • sudo mysql_secure_installation

      Mit der ersten Eingabeaufforderung werden Sie aufgefordert, das aktuelle Datenbank-Root-Passwort einzugeben. Und weil Sie MariaDB gerade installiert und noch keine Konfigurationsänderungen vorgenommen haben, ist dieses Passwort leer. Drücken Sie also bei der Eingabeaufforderung einfach die EINGABETASTE.

      Bei der nächsten Eingabeaufforderung werden Sie gefragt, ob Sie ein Datenbank-Root-Passwort einrichten möchten. Und weil MariaDB eine spezielle Authentifizierungsmethode für den Root-Benutzer verwendet, die typischerweise sicherer ist als ein Passwort, müssen Sie das jetzt nicht einrichten. Geben Sie N ein und drücken Sie dann die EINGABETASTE.

      Von dort aus können Sie Y und dann die EINGABETASTE drücken, um die Standardeinstellungen für alle nachfolgenden Fragen zu akzeptieren.

      Wenn Sie fertig sind, melden Sie sich bei der MariaDB-Konsole an, indem Sie Folgendes eingeben:

      Damit wird eine Verbindung zum MariaDB-Server als administrativer Datenbank-Benutzer root hergestellt, was durch die Verwendung von sudo abgeleitet wird, wenn dieser Befehl ausgeführt wird. Sie sollten eine Ausgabe wie diese sehen:

      Output

      Welcome to the MariaDB monitor. Commands end with ; or g. Your MariaDB connection id is 9 Server version: 10.3.17-MariaDB MariaDB Server Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others. Type 'help;' or 'h' for help. Type 'c' to clear the current input statement. MariaDB [(none)]>

      Um eine neue Datenbank zu erstellen, führen Sie den folgenden Befehl von Ihrer MariaDB-Konsole aus:

      • CREATE DATABASE example_database;

      Jetzt können Sie einen neuen Benutzer erstellen und ihm volle Berechtigungen auf der benutzerdefinierten Datenbank gewähren, die Sie gerade erstellt haben:

      • GRANT ALL ON example_database.* TO 'example_user'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;

      Aktualisieren Sie die Berechtigungen (über „flush privileges“), um sicherzustellen, dass sie in der aktuellen Sitzung gespeichert und verfügbar sind:

      Beenden Sie anschließend die MariaDB Shell:

      Schritt 3 – Installation von PHP-FPM

      Um die php-fpm– und php-mysql-Pakete zu installieren, führen Sie Folgendes aus:

      • sudo dnf install php-fpm php-mysqlnd

      Wenn die Installation abgeschlossen ist, müssen Sie die Datei /etc/php-fpm.d/www.conf bearbeiten, um ein paar Einstellungen anzupassen. Wir installieren nano, um das Bearbeiten dieser Dateien zu erleichtern:

      Öffnen Sie dann die Konfigurationsdatei /etc/php-fpm.d/www.conf mit nano oder Ihrem bevorzugten Textbearbeitungsprogramm:

      • sudo nano /etc/php-fpm.d/www.conf

      Suchen Sie nach den Anweisungen user und group. Wenn Sie nano verwenden, können Sie auf STRG+W drücken, um in der offenen Datei nach diesen Begriffen zu suchen. Vergewissern Sie sich, dass Sie beide Werte von apache auf nginx ändern:

      /etc/php-fpm.d/www.conf

      …
      ; RPM: apache user chosen to provide access to the same directories as httpd
      user = nginx
      ; RPM: Keep a group allowed to write in log dir.
      group = nginx

      Speichern und schließen Sie die Datei, wenn die Bearbeitung abgeschlossen ist.

      Zur Aktivierung und zum Start des php-fpm-Dienstes führen Sie Folgendes aus:

      • sudo systemctl start php-fpm

      Starten Sie schließlich den Nginx-Webserver neu, damit er die Konfigurationsdateien lädt, die durch die php-fpm-Installation erstellt wurden:

      • sudo systemctl restart nginx

      Schritt 4 – Testen Sie PHP mit Nginx

      In CentOS 8 erstellt die Standard php-fpm-Installation automatisch Konfigurationsdateien, die Ihrem Nginx-Webserver erlauben, .php-Dateien im Standard-Dokumentstamm zu bearbeiten, der sich unter /usr/share/nginx/html befindet. Sie müssen keine Änderungen der Nginx-Konfiguration vornehmen, damit PHP korrekt in Ihrem Webserver funktioniert.

      Wir müssen lediglich den Standard-Eigentümer und die Gruppe im Nginx-Dokumentstamm ändern, damit Sie Dateien an diesem Speicherort mit Ihrem normalen Systembenutzer ohne Rootberechtigung erstellen und ändern können.

      • sudo chown -R sammy.sammy /usr/share/nginx/html/

      Erstellen Sie eine neue PHP Datei namens info.php im Verzeichnis /usr/share/nginx/html:

      • nano /usr/share/nginx/html/info.php

      Der folgende PHP-Code zeigt Informationen über die aktuelle PHP-Umgebung, die auf dem Server läuft:

      /usr/share/nginx/html/info.php

      <?php
      
      phpinfo();
      

      Kopieren Sie diesen Inhalt in Ihre info.php-Datei und vergessen Sie nicht, sie zu speichern, wenn Sie fertig sind.

      Jetzt können wir testen, ob unser Webserver den Inhalt korrekt anzeigt, der durch ein PHP-Skript erstellt wurde. Gehen Sie zu Ihrem Browser und greifen Sie auf Ihren Server-Hostnamen oder die IP-Adresse zu, gefolgt von /info.php:

      http://server_host_or_IP/info.php
      

      Sie sehen eine Seite, die so ähnlich wie die folgende aussieht:

      CentOS 8 Standard-PHP-Info

      Relevante Tutorials

      Hier sehen Sie Links zu detaillierteren Leitfäden, die in Verbindung mit diesem Tutorial stehen:



      Source link

      So richten Sie Apache Virtual Hosts unter Ubuntu 18.04 ein [Schnellstart]


      Einführung

      Dieses Tutorial führt Sie durch das Einrichten mehrerer Domänen und Websites mit virtuellen Apache-Hosts auf einem Ubuntu 18.04-Server. Bei diesem Prozess lernen Sie, wie Sie je nach Art der angeforderten Domäne verschiedenen Benutzern unterschiedlichen Inhalt bereitstellen können.

      Eine ausführlichere Version dieses Tutorials mit besseren Erklärungen zu den einzelnen Schritten finden Sie unter So installieren Sie Apache Virtual Hosts unter Ubuntu 18.04.

      Voraussetzungen

      Um diesem Tutorial zu folgen, benötigen Sie Zugriff auf Folgendes auf einem Ubuntu-18.04-Server:

      • Einen Sudo-Benutzer auf Ihrem Server
      • Einen Apache2-Webserver, den Sie mit sudo apt install apache2 installieren können

      Schritt 1 – Verzeichnisstruktur erstellen

      Zunächst erstellen wir eine Verzeichnisstruktur, in der die Site-Daten gespeichert werden, die wir den Besuchern in unserem Top-Level-Apache-Verzeichnis bereitstellen können. Wir verwenden Beispiele von Domänennamen, die nachstehend hervorgehoben sind. Sie müssen diese durch Ihre tatsächlichen Domänennamen ersetzen.

      • sudo mkdir -p /var/www/example.com/public_html
      • sudo mkdir -p /var/www/test.com/public_html

      Schritt 2 – Berechtigungen erteilen

      Jetzt müssen wir die Berechtigungen auf unseren aktuellen Benutzer ohne Rootberechtigung ändern, um diese Dateien ändern zu können.

      • sudo chown -R $USER:$USER /var/www/example.com/public_html
      • sudo chown -R $USER:$USER /var/www/test.com/public_html

      Außerdem stellen wir sicher, dass der schreibgeschützte Zugriff auf das allgemeine Webverzeichnis und alle darin enthaltenen Dateien und Ordner gestattet ist, damit Seiten richtig bereitgestellt werden können.

      • sudo chmod -R 755 /var/www

      Schritt 3 – Demo-Seiten für jeden virtuellen Host erstellen

      Erstellen wir jetzt Inhalt, den wir bereitstellen können. Dazu erstellen wir eine index.html-Demo-Seite für jede Site. Wir können eine index.html-Datei in einem Textbearbeitungsprogramm für unsere erste Site öffnen, beispielsweise nano.

      • nano /var/www/example.com/public_html/index.html

      In dieser Datei erstellen wir dann ein domänenspezifisches HTML-Dokument wie das folgende:

      /var/www/example.com/public_html/index.html

      <html>
        <head>
          <title>Welcome to Example.com!</title>
        </head>
        <body>
          <h1>Success! The example.com virtual host is working!</h1>
        </body>
      </html>
      

      Speichern und schließen Sie die Datei und kopieren Sie dann diese Datei als Grundlage für unsere zweite Site:

      • cp /var/www/example.com/public_html/index.html /var/www/test.com/public_html/index.html

      Öffnen Sie die Datei und ändern Sie die relevanten Informationen:

      • nano /var/www/test.com/public_html/index.html

      /var/www/test.com/public_html/index.html

      <html>
        <head>
          <title>Welcome to Test.com!</title>
        </head>
        <body> <h1>Success! The test.com virtual host is working!</h1>
        </body>
      </html>
      

      Speichern und schließen Sie auch diese Datei.

      Schritt 4 – Neue virtuelle Host-Dateien erstellen

      Apache wird mit einer virtuellen Standard-Host-Datei namens 000-default.conf geliefert, die wir als Vorlage verwenden. Wir kopieren sie, um eine virtuelle Host-Datei für jede unserer Domänen zu erstellen.

      Erste virtuelle Host-Datei erstellen

      Kopieren Sie als Erstes die Datei für die erste Domäne:

      • sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/example.com.conf

      Öffnen Sie die neue Datei in Ihrem Textbearbeitungsprogramm (wir verwenden nano) mit Rootberechtigungen:

      • sudo nano /etc/apache2/sites-available/example.com.conf

      Wir werden diese Datei für unsere eigene Domäne anpassen. Ändern Sie den nachstehend hervorgehobenen Text je nach Bedarf.

      /etc/apache2/sites-available/example.com.conf

      <VirtualHost *:80>
          ServerAdmin admin@example.com
          ServerName example.com
          ServerAlias www.example.com
          DocumentRoot /var/www/example.com/public_html
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Speichern und schließen Sie dann die Datei.

      Ersten virtuellen Host kopieren und für die zweite Domäne anpassen

      Jetzt haben wir unsere erste virtuelle Host-Datei eingerichtet und können dann unsere zweite Datei erstellen, indem wir diese Datei kopieren und je nach Bedarf anpassen.

      Kopieren Sie zu diesem Zweck die Datei:

      • sudo cp /etc/apache2/sites-available/example.com.conf /etc/apache2/sites-available/test.com.conf

      Öffnen Sie die neue Datei mit Rootberechtigungen in Ihrem Textbearbeitungsprogramm:

      • sudo nano /etc/apache2/sites-available/test.com.conf

      Jetzt müssen Sie alle Informationen so ändern, dass sie auf Ihre zweite Domäne verweisen. Die endgültige Datei sollte in etwa wie folgt aussehen, wobei der hervorgehobene Text Ihren eigenen Domäneninformationen entsprechen sollte.

      /etc/apache2/sites-available/test.com.conf

      <VirtualHost *:80>
          ServerAdmin admin@test.com
          ServerName test.com
          ServerAlias www.test.com
          DocumentRoot /var/www/test.com/public_html
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Wenn Sie fertig sind, speichern und schließen Sie die Datei.

      Schritt 5 – Neue virtuelle Host-Dateien aktivieren

      Nach Erstellung unserer virtuellen Host-Dateien müssen diese aktiviert werden. Dazu verwenden wir das a2ensite-Tool.

      • sudo a2ensite example.com.conf
      • sudo a2ensite test.com.conf

      Deaktivieren Sie als Nächstes die unter 000-default.conf definierte Standard-Site:

      • sudo a2dissite 000-default.conf

      Wenn Sie fertig sind, müssen Sie Apache neu starten, damit diese Änderungen wirksam werden, und systemctl status verwenden, um den Erfolg des Neustarts zu verifizieren.

      • sudo systemctl restart apache2

      Ihr Server sollte jetzt für zwei Websites eingerichtet sein.

      Schritt 6 – Lokale Hosts-Datei einrichten (optional)

      Wenn Sie keine tatsächlichen Domänen verwenden, die ihnen gehören, um dieses Verfahren zu testen, und stattdessen Beispielsdomänen benutzen, können Sie Ihre Arbeit testen, indem Sie die hosts-Datei auf Ihrem lokalen Computer kurzzeitig ändern.

      Geben Sie auf einem lokalen Mac- oder Linux-Rechner Folgendes ein:

      Für einen lokalen Windows-Rechner finden Sie Anweisungen zur Änderung Ihrer Hosts-Datei hier.

      Nach Verwenden der in diesem Leitfaden verwendeten Domänen und Ersetzen Ihrer Server IP im Text your_server_IP sollte Ihre Datei wie folgt aussehen:

      /etc/hosts

      127.0.0.1   localhost
      127.0.1.1   guest-desktop
      your_server_IP example.com
      your_server_IP test.com
      

      Speichern und schließen Sie die Datei. Damit werden alle Anfragen z. B. example.com und test.com auf unseren Rechner weitergeleitet und auf unseren Server übertragen.

      Schritt 7 – Ergebnisse testen

      Nach der Konfiguration Ihrer virtuellen Hosts können Sie Ihr Setup testen, indem Sie zu den Domänen gehen, die Sie in Ihrem Web-Browser konfiguriert haben.

      http://example.com
      

      Sie sollten eine Seite sehen, die so aussieht:

      Beispiel für einen virtuellen Apache-Host

      Sie können auch Ihre zweite Seite besuchen und die Datei sehen, die Sie für Ihre zweite Site erstellt haben.

      http://test.com
      

      Test für einen virtuellen Apache-Host

      Wenn beide Sites wie erwartet funktionieren, haben Sie zwei virtuelle Hosts auf ein und demselben Server konfiguriert.

      Wenn Sie die Host-Datei Ihres eigenen Rechners angepasst haben, löschen Sie die von Ihnen hinzugefügte Zeilen.

      Relevante Tutorials

      Hier sehen Sie Links zu detaillierteren Leitfäden, die im Zusammenhang zu diesem Tutorial stehen:



      Source link