One place for hosting & domains

      Einrichten

      Installieren und Einrichten von Laravel mit Docker Compose unter Ubuntu 20.4


      Einführung

      Die Containerisierung einer Anwendung bezeichnet den Anpassungsprozess einer Anwendung und ihrer Komponenten, um sie in einfachen Umgebungen ausführen zu können, die als Container bekannt sind. Derartige Umgebungen sind isoliert und können gelöscht werden. Sie lassen sich zur Entwicklung, zum Testen und zur Bereitstellung von Anwendungen zu Produktionszwecken nutzen.

      In diesem Leitfaden verwenden wir Docker Compose, um eine Laravel-Anwendung für die Entwicklung zu containerisieren. Wenn Sie fertig sind, haben Sie eine Testversion der Laravel-Anwendung, die auf drei separaten Dienst-Containern ausgeführt wird:

      • einen app-Dienst, der PHP7.4-FPM ausführt;
      • einen db-Dienst, der MySQL 5.7 ausführt;
      • einen nginx-Dienst, der den app-Dienst verwendet, um den PHP-Code zu parsen, bevor die Laravel-Anwendung dem Endbenutzer bereitgestellt wird.

      Um einen gestrafften Entwicklungsprozess zu ermöglichen und das Debugging der Anwendung zu ermöglichen, halten wir Anwendungsdateien durch den Einsatz von gemeinsam genutzten Volumes synchron. Auch zeigen wir, wie Sie docker-compose exec-Befehle verwenden, um Composer und Artisan auf dem app-Container auszuführen.

      Voraussetzungen

      Schritt 1 – Erhalt der Demo-Anwendung

      Zu Beginn rufen wir die Demoversion der Laravel-Anwendung aus dem Github Repository ab. Wir sind an dem tutorial-01-Zweig interessiert, der die Laravel-Standardanwendung enthält, die wir im ersten Leitfaden dieser Serie erstellt haben.

      Um den mit diesem Tutorial kompatiblen Anwendungscode zu bekommen, laden Sie wie folgt tutorial-1.0.1 in Ihr Stammverzeichnis herunter:

      • cd ~
      • curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-1.0.1.zip -o travellist.zip

      Den unzip-Befehl brauchen wir, um den Anwendungscode zu dekomprimieren. Wenn Sie dieses Paket noch nicht installiert haben, sollten Sie es jetzt wie folgt tun:

      • sudo apt update
      • sudo apt install unzip

      Dekomprimieren Sie nun den Inhalt der Anwendung und benennen Sie das entpackte Verzeichnis für leichteren Zugriff um:

      • unzip travellist.zip
      • mv travellist-laravel-demo-tutorial-1.0.1 travellist-demo

      Navigieren Sie zum Verzeichnis travellist-demo:

      Im nächsten Schritt erstellen wir eine .env-Konfigurationsdatei, um die Anwendung einzurichten.

      Schritt 2 – Einrichten der .env-Datei der Anwendung

      Die Laravel-Konfigurationsdateien befinden sich im Verzeichnis config, das Sie im Stammverzeichnis der Anwendung finden. Zusätzlich wird eine .env-Datei verwendet, um eine umgebungsabhängige Konfiguration einzurichten, wie z. B. Anmeldedaten und Informationen, die sich zwischen Bereitstellungen ändern können. Diese Datei ist nicht Teil der Revisionskontrolle.

      Warnung: Die Umgebungs-Konfigurationsdatei enthält sensible Informationen über Ihren Server, einschließlich Anmeldedaten zur Datenbank und Sicherheitsschlüssel. Aus diesem Grund sollten Sie diese Datei nie öffentlich teilen.

      Die Werte in der .env-Datei haben Vorrang vor den Werten, die in regelmäßigen Konfigurationsdateien festgelegt sind, die sich im Verzeichnis config befinden. Jede Installation in einer neuen Umgebung erfordert eine maßgeschneiderte Umgebungsdatei, um Dinge wie Datenbank-Verbindungseinstellungen, Debug-Optionen, Anwendungs-URL und andere Objekte festzulegen, die je nach den Umgebungsbedingungen variieren können.

      Jetzt erstellen wir eine neue .env-Datei, um die Konfigurationsoptionen für die Entwicklungsumgebung anzupassen, die wir einrichten. Laravel wird mit einer .env-Musterdatei geliefert, die wir zur Erstellung unserer eigenen kopieren können:

      Öffnen Sie diese Datei mit nano oder dem Texteditor Ihrer Wahl:

      Die aktuelle .env-Datei aus der travellist Demo-Anwendung enthält Einstellungen zum Einsatz einer lokalen MySQL-Datenbank, wobei 127.0.0.1 der Datenbank-Host ist. Wir müssen die Variable DB_HOST aktualisieren, damit sie auf den Datenbankdienst verweist, den wir in unserer Docker-Umgebung erstellen. In diesem Leitfaden nennen wir unseren Datenbankdienst db. Ersetzen Sie also den aufgelisteten Wert von DB_HOST durch den Datenbankdienstnamen:

      .env

      APP_NAME=Travellist
      APP_ENV=dev
      APP_KEY=
      APP_DEBUG=true
      APP_URL=http://localhost:8000
      
      LOG_CHANNEL=stack
      
      DB_CONNECTION=mysql
      DB_HOST=db
      DB_PORT=3306
      DB_DATABASE=travellist
      DB_USERNAME=travellist_user
      DB_PASSWORD=password
      ...
      

      Sie können den Datenbanknamen, den Benutzernamen und das Passwort auch nach Bedarf ändern. Diese Variablen werden in einem späteren Schritt genutzt, wo wir die Datei docker-compose.yml einrichten, um unsere Dienste zu konfigurieren.

      Speichern Sie die Datei, wenn die Bearbeitung abgeschlossen ist. Wenn Sie nano verwendet haben, können Sie zur Bestätigung Strg+x, dann Y und die Eingabetaste drücken.

      Schritt 3 – Einrichten des Dockerfiles der Anwendung

      Obwohl unsere MySQL- und Nginx Dienste auf Standardimages basieren, die wir aus dem Docker Hub erhalten, müssen wir trotzdem ein benutzerdefiniertes Image für den Anwendungs-Container erstellen. Dafür erstellen wir ein neues Dockerfile.

      Unser travellist-Image basiert auf dem offiziellen PHP-Image php:7.4-fpm von Docker Hub. Über diese PHP-FPM-Umgebung hinaus installieren wir ein paar PHP-Extramodule und das Composer Abhängigkeitsmanagement-Tool.

      Außerdem erstellen wir einen neuen Systembenutzer; dies ist notwendig, um artisan– und composer– Befehle während der Entwicklung der Anwendung auszuführen. Die uid-Einstellung stellt sicher, dass der Benutzer im Container dieselbe UID wie der Systembenutzer auf Ihrem Host-Computer hat, auf dem Docker läuft. Auf diese Weise werden alle von diesen Befehlen erstellten Dateien mit den richtigen Berechtigungen im Host repliziert. Es bedeutet auch, dass Sie auf dem Host-Rechner den Code-Editor Ihrer Wahl verwenden können, um die Anwendung für die Container zu entwickeln.

      Erstellen Sie ein neues Dockerfile mit:

      Kopieren Sie den folgenden Inhalt in Ihr Dockerfile:

      Dockerfile

      FROM php:7.4-fpm
      
      # Arguments defined in docker-compose.yml
      ARG user
      ARG uid
      
      # Install system dependencies
      RUN apt-get update && apt-get install -y 
          git 
          curl 
          libpng-dev 
          libonig-dev 
          libxml2-dev 
          zip 
          unzip
      
      # Clear cache
      RUN apt-get clean && rm -rf /var/lib/apt/lists/*
      
      # Install PHP extensions
      RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd
      
      # Get latest Composer
      COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
      
      # Create system user to run Composer and Artisan Commands
      RUN useradd -G www-data,root -u $uid -d /home/$user $user
      RUN mkdir -p /home/$user/.composer && 
          chown -R $user:$user /home/$user
      
      # Set working directory
      WORKDIR /var/www
      
      USER $user
      
      

      Vergessen Sie nicht, die Datei zu speichern, wenn Sie fertig sind.

      Unser Dockerfile beginnt, indem Sie das Basisimage definieren, das wir verwenden: php:7.4-fpm.

      Nach Installation von Systempaketen und PHP-Erweiterungen installieren wir Composer, indem wir den ausführbaren composer aus dem letzten offiziellen Image in unser eigenes Anwendungsimage kopieren.

      Dann wird mit den Argumenten user und uid ein neuer Systembenutzer erstellt und eingerichtet. Diese Argumente wurden zu Beginn des Dockerfiles deklariert. Diese Werte werden von Docker Compose zur Buildzeit injiziert.

      Schließlich legen wir das Standardarbeitsverzeichnis als /var/www fest und wechseln auf den neu erstellten Benutzer. Somit gewährleisten Sie, dass Sie sich als regelmäßiger Benutzer verbinden und im richtigen Verzeichnis sind, wenn Sie composer– und artisan-Befehle im Anwendungs-Container ausführen.

      Schritt 4 – Einrichten der Nginx-Konfiguration und der Datenbank-Dump-Dateien

      Wenn Sie Entwicklungsumgebungen mit Docker Compose erstellen, müssen Sie die Konfigurations- oder Initialisierungsdateien häufig mit Dienst-Containern teilen, um diese Dienste einzurichten oder im Bootstrap-Verfahren zu laden. Diese Vorgehensweise ermöglicht die Änderung der Konfigurationsdateien, um Ihre Umgebung während der Anwendungsentwicklung genau einzustellen.

      Jetzt erstellen wir einen Ordner mit Dateien, die zur Konfiguration und Initialisierung unserer Dienst-Container verwendet werden.

      Um Nginx einzurichten, teilen wir eine travellist.conf Datei, die festlegt, wie die Anwendung bereitgestellt wird. Erstellen Sie den Ordner docker-compose/nginx wie folgt:

      • mkdir -p docker-compose/nginx

      Öffnen Sie eine neue Datei namens travellist.conf in diesem Verzeichnis:

      • nano docker-compose/nginx/travellist.conf

      Kopieren Sie die folgende Nginx-Konfiguration in diese Datei:

      docker-compose/nginx/travellist.conf

      
      server {
          listen 80;
          index index.php index.html;
          error_log  /var/log/nginx/error.log;
          access_log /var/log/nginx/access.log;
          root /var/www/public;
          location ~ .php$ {
              try_files $uri =404;
              fastcgi_split_path_info ^(.+.php)(/.+)$;
              fastcgi_pass app:9000;
              fastcgi_index index.php;
              include fastcgi_params;
              fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
              fastcgi_param PATH_INFO $fastcgi_path_info;
          }
          location / {
              try_files $uri $uri/ /index.php?$query_string;
              gzip_static on;
          }
      }
      

      Mit dieser Datei wird Nginx konfiguriert, um auf Port 80 zu lauschen und index.php als standardmäßige Index-Seite zu verwenden. Damit wird der Dokumentenstamm auf /var/www/public festgelegt und dann Nginx so konfiguriert, dass er den app-Dienst auf Port 9000 verwendet, um *.php-Dateien zu verarbeiten.

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

      Um die MySQL-Datenbank einzurichten, teilen wir einen Datenbank-Dump, der bei Initialisierung des Containers importiert wird. Dies ist eine Eigenschaft, die vom MySQL 5.7-Image bereitgestellt wird, das wir in dem Container verwenden.

      Erstellen Sie einen neuen Ordner für Ihre MySQL-Initialisierung im Ordner docker-compose:

      • mkdir docker-compose/mysql

      Öffnen Sie eine neue .sql-Datei:

      • nano docker-compose/mysql/init_db.sql

      Der folgende MySQL-Dump basiert auf der Datenbank, die wir in unserem Leitfaden zu Laravel mit LEMP eingerichtet haben. Damit wird eine neue Tabelle namens places erstellt. Dann füllt er die Tabelle mit einem Satz von Musterstellen.

      Fügen Sie den folgenden Code zur Datei hinzu:

      docker-compose/mysql/db_init.sql

      DROP TABLE IF EXISTS `places`;
      
      CREATE TABLE `places` (
        `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
        `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
        `visited` tinyint(1) NOT NULL DEFAULT '0',
        PRIMARY KEY (`id`)
      ) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
      
      INSERT INTO `places` (name, visited) VALUES ('Berlin',0),('Budapest',0),('Cincinnati',1),('Denver',0),('Helsinki',0),('Lisbon',0),('Moscow',1),('Nairobi',0),('Oslo',1),('Rio',0),('Tokyo',0);
      

      Die Tabelle places enthält drei Felder: id, name und visited. Das Feld visited ist ein Flag, das als Identifizierung der Stellen dient, die noch ausstehen. Stellen Sie diese Musterstellen nach Belieben um oder setzen Sie neue hinzu. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

      Damit ist die Einrichtung des Dockerfiles der Anwendung und der Konfigurationsdateien des Dienstes abgeschlossen. Als Nächstes richten wir Docker Compose ein, damit es bei der Erstellung unserer Dienste diese Dateien verwendet.

      Schritt 5 – Erstellen einer Multi-Container-Umgebung mit Docker Compose

      Docker Compose ermöglicht es Ihnen, Multi-Container-Umgebungen für auf Docker laufende Anwendungen zu erstellen. Er verwendet Dienst-Definitionen zum Aufbau voll anpassbarer Umgebungen mit mehreren Containern, die Netzwerke und Datenvolumes teilen können. Damit wird eine nahtlose Integration zwischen Anwendungskomponenten möglich.

      Um unsere Dienst-Definitionen einzurichten, erstellen wir eine neue Datei namens docker-compose.yml. Normalerweise befindet sich diese Datei im Stamm des Anwendungsordners und definiert die containerisierte Umgebung, einschließlich der Standardimages, die Sie zum Aufbau Ihrer Container verwenden, und der Art und Weise, wie Ihre Dienste interagieren.

      Wir definieren drei verschiedene Dienste in unserer docker-compose.yml-Datei: app, db und nginx.

      Der app-Dienst stellt ein Image mit der Bezeichnung travellist auf Basis des zuvor erstellten Dockerfiles zusammen. Der durch diesen Dienst definierte Container führt einen php-fpm-Server aus, um PHP-Code zu parsen und die Ergebnisse an den nginx-Dienst zurückzusenden, der in einem separaten Container läuft. Der mysql-Dienst definiert einen Container, der einen MySQL 5.7-Server ausführt. Unsere Dienste teilen ein Brückennetzwerk namens travellist.

      Die Anwendungsdateien werden in sowohl den app– als auch den nginx-Diensten über Bind-Bereitstellungen synchronisiert. Bind-Bereitstellungen sind in Entwicklungsumgebungen nützlich, weil sie eine performante zweispurige Synchronisierung zwischen Host-Rechner und Containern ermöglichen.

      Erstellen Sie eine neue docker-compose.yml-Datei im Stammverzeichnis der Anwendung:

      Eine typische docker-compose.yml-Datei beginnt mit einer Versionsdefinition gefolgt von einem services-Knoten, in dem alle Dienste definiert sind. Die geteilten Netzwerke werden normalerweise unten in der Datei definiert.

      Kopieren Sie zu Beginn diesen Standardcode in Ihre docker-compose.yml-Datei:

      docker-compose.yml

      version: "3.7"
      services:
      
      
      networks:
        travellist:
          driver: bridge
      

      Jetzt bearbeiten wir den services-Knoten, um die app-, db– und nginx-Dienste aufzunehmen.

      Der app-Dienst

      Der app-Dienst richtet einen Container namens travellist-app ein. Basierend auf einem Dockerfile mit dem gleichen Pfad wie die docker-compose.yml-Datei baut er ein neues Docker-Image auf. Das neue Image wird lokal unter dem Namen travellist gespeichert.

      Obwohl sich der als Anwendung dienende Dokumentenstamm im nginx-Container befindet, sollten auch die Anwendungsdateien irgendwo im app-Container vorhanden sein, damit wir Befehlszeilenvorgänge mit dem Laravel Artisan-Tool ausführen können.

      Kopieren Sie die folgende Dienst-Definition in Ihrem services-Knoten aus der docker-compose.yml-Datei:

      docker-compose.yml

        app:
          build:
            args:
              user: sammy
              uid: 1000
            context: ./
            dockerfile: Dockerfile
          image: travellist
          container_name: travellist-app
          restart: unless-stopped
          working_dir: /var/www/
          volumes:
            - ./:/var/www
          networks:
            - travellist
      

      Diese Einstellungen bewirken Folgendes:

      • build: Diese Konfiguration weist Docker Compose an, ein lokales Image für den app-Dienst zu erstellen, wobei es den angegebenen Pfad (context) und das Dockerfile für Anweisungen verwendet. Die Argumente user und uid werden in das Dockerfile injiziert, um die Befehle zur Benutzereinrichtung zur Buildzeit anzupassen.
      • image: Der Name, der für das zusammengestellte Image verwendet wird.
      • container_name: Richtet den Container-Namen für diesen Dienst ein.
      • restart: Es wird immer ein Neustart durchgeführt, es sei denn, der Dienst wird angehalten.
      • working_dir: Richtet das Standardverzeichnis für diesen Dienst als /var/www ein.
      • volumes: Erstellt ein gemeinsam genutztes Volume, das den Inhalt des aktuellen Verzeichnisses auf /var/www im Container synchronisiert. Beachten Sie, dass es sich nicht um Ihren Dokumentenstamm handelt, da dieser sich im nginx-Container befinden wird.
      • networks: Richtet diesen Dienst auf Nutzung eines Netzwerks namens travellist ein.

      Der db-Dienst

      Der db-Dienst verwendet ein vorab zusammengestelltes MySQL 5.7-Image von Docker Hub. Da Docker Compose die .env-Variablendateien automatisch lädt, die sich im gleichen Verzeichnis wie die docker-compose.yml-Datei befinden, erhalten wir unsere Datenbankeinstellungen aus der Laravel .env-Datei, die wir im vorherigen Schritt erstellt haben.

      Setzen Sie die folgende Dienst-Definition in Ihrem services-Knoten direkt hinter den app-Dienst:

      docker-compose.yml

        db:
          image: mysql:5.7
          container_name: travellist-db
          restart: unless-stopped
          environment:
            MYSQL_DATABASE: ${DB_DATABASE}
            MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
            MYSQL_PASSWORD: ${DB_PASSWORD}
            MYSQL_USER: ${DB_USERNAME}
            SERVICE_TAGS: dev
            SERVICE_NAME: mysql
          volumes:
            - ./docker-compose/mysql:/docker-entrypoint-initdb.d
          networks:
            - travellist
      

      Diese Einstellungen bewirken Folgendes:

      • image: Definiert das Docker-Image, das für diesen Container verwendet werden sollte. In diesem Fall verwenden wir ein MySQL 5.7-Image von Docker Hub.
      • container_name: Richtet den Container-Namen für diesen Dienst ein: travellist-db.
      • restart: Dieser Dienst wird immer neu gestartet, es sei denn, er wurde ausdrücklich angehalten.
      • environment: Definiert Umgebungsvariablen im neuen Container. Wir verwenden Werte aus der Laravel .env-Datei, um unseren MySQL-Dienst einzurichten. Damit werden automatisch, basierend auf den bereitgestellten Umgebungsvariablen, eine neue Datenbank und ein Benutzer erstellt.
      • volumes: Erstellt ein Volume, um einen .sql-Datenbank-Dump zu teilen, der zur Initialisierung der Anwendungsdatenbank verwendet wird. Das MySQL-Image importiert automatisch .sql-Dateien, die im Verzeichnis /docker-entrypoint-initdb.d im Container abgelegt werden.
      • networks: Richtet diesen Dienst auf Nutzung eines Netzwerks namens travellist ein.

      Der nginx-Dienst

      Der nginx-Dienst verwendet ein vorab zusammengestelltes Nginx-Image auf Alpine, einer einfachen Linux-Distribution. Damit wird ein Container namens travellist-nginx erstellt und die ports-Definition verwendet, um eine Umleitung von Port 8000 im Host-System auf Port 80 im Container zu schaffen.

      Setzen Sie die folgende Dienst-Definition in Ihrem services-Knoten direkt hinter den db-Dienst:

      docker-compose.yml

        nginx:
          image: nginx:1.17-alpine
          container_name: travellist-nginx
          restart: unless-stopped
          ports:
            - 8000:80
          volumes:
            - ./:/var/www
            - ./docker-compose/nginx:/etc/nginx/conf.d
          networks:
            - travellist
      

      Diese Einstellungen bewirken Folgendes:

      • image: Definiert das Docker-Image, das für diesen Container verwendet werden sollte. In diesem Fall verwenden wir das Alpine Nginx 1.17-Image.
      • container_name: Richtet den Container-Namen für diesen Dienst ein: travellist-nginx.
      • restart: Dieser Dienst wird immer neu gestartet, es sei denn, er wurde ausdrücklich angehalten.
      • ports: Richtet eine Port-Umleitung ein, die den externen Zugriff über Port 8000 auf den Web-Server ermöglicht, der auf Port 80 im Container läuft.
      • volumes: Erstellt zwei gemeinsam genutzte Volumes. Das erste wird den Inhalt aus dem aktuellen Verzeichnis in /var/www im Container synchronisieren. Auf diese Weise werden bei lokalen Änderungen an den Anwendungsdateien diese schnell in der Anwendung widergespiegelt, die von Nginx im Container bereitgestellt wird. Das zweite Volume stellt sicher, dass unsere Nginx-Konfigurationsdatei, die sich auf docker-compose/nginx/travellist.conf befindet, in den Nginx-Konfigurationsordner des Containers kopiert wird.
      • networks: Richtet diesen Dienst auf Nutzung eines Netzwerks namens travellist ein.

      Fertiggestellte docker-compose.yml-Datei

      So sieht unsere fertiggestellte docker-compose.yml-Datei aus:

      docker-compose.yml

      version: "3.7"
      services:
        app:
          build:
            args:
              user: sammy
              uid: 1000
            context: ./
            dockerfile: Dockerfile
          image: travellist
          container_name: travellist-app
          restart: unless-stopped
          working_dir: /var/www/
          volumes:
            - ./:/var/www
          networks:
            - travellist
      
        db:
          image: mysql:5.7
          container_name: travellist-db
          restart: unless-stopped
          environment:
            MYSQL_DATABASE: ${DB_DATABASE}
            MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
            MYSQL_PASSWORD: ${DB_PASSWORD}
            MYSQL_USER: ${DB_USERNAME}
            SERVICE_TAGS: dev
            SERVICE_NAME: mysql
          volumes:
            - ./docker-compose/mysql:/docker-entrypoint-initdb.d
          networks:
            - travellist
      
        nginx:
          image: nginx:alpine
          container_name: travellist-nginx
          restart: unless-stopped
          ports:
            - 8000:80
          volumes:
            - ./:/var/www
            - ./docker-compose/nginx:/etc/nginx/conf.d/
          networks:
            - travellist
      
      networks:
        travellist:
          driver: bridge
      

      Denken Sie daran, die Datei zu speichern, wenn Sie Ihre Bearbeitung abgeschlossen haben.

      Schritt 6 – Ausführung der Anwendung mit Docker Compose

      Jetzt verwenden wir docker-compose-Befehle, um das Anwendungsimage zu erstellen und die Dienste auszuführen, die wir in unserem Setup festgelegt haben.

      Erstellen Sie das app-Image mit dem folgenden Befehl:

      Dies kann einige Minuten dauern. Sie sehen eine Ausgabe, die dieser ähnelt:

      Output

      Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in f71eb33b7459 Removing intermediate container f71eb33b7459 ---> 533c30216f34 Step 3/11 : ARG uid ---> Running in 60d2d2a84cda Removing intermediate container 60d2d2a84cda ---> 497fbf904605 Step 4/11 : RUN apt-get update && apt-get install -y git curl libpng-dev libonig-dev ... Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer ---> e499f74896e3 Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user ---> Running in 232ef9c7dbd1 Removing intermediate container 232ef9c7dbd1 ---> 870fa3220ffa Step 9/11 : RUN mkdir -p /home/$user/.composer && chown -R $user:$user /home/$user ---> Running in 7ca8c0cb7f09 Removing intermediate container 7ca8c0cb7f09 ---> 3d2ef9519a8e Step 10/11 : WORKDIR /var/www ---> Running in 4a964f91edfa Removing intermediate container 4a964f91edfa ---> 00ada639da21 Step 11/11 : USER $user ---> Running in 9f8e874fede9 Removing intermediate container 9f8e874fede9 ---> fe176ff4702b Successfully built fe176ff4702b Successfully tagged travellist:latest

      Wenn der Build abgeschlossen ist, können Sie die Umgebung im Hintergrundmodus ausführen:

      Output

      Creating travellist-db ... done Creating travellist-app ... done Creating travellist-nginx ... done

      Damit werden Ihre Container im Hintergrund ausgeführt. Um Informationen über den Zustand Ihrer aktiven Dienste anzuzeigen, führen Sie Folgendes aus:

      Die Ausgabe sieht dann so aus:

      Output

      Name Command State Ports -------------------------------------------------------------------------------- travellist-app docker-php-entrypoint php-fpm Up 9000/tcp travellist-db docker-entrypoint.sh mysqld Up 3306/tcp, 33060/tcp travellist-nginx /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp

      Jetzt ist Ihre Umgebung einsatzbereit, aber wir müssen noch ein paar Befehle ausführen, um das Setup der Anwendung abzuschließen. Sie können den Befehl docker-compose exec verwenden, um Befehle in den Dienst-Containern auszuführen, wie z. B. ls -l, der detaillierte Informationen über Dateien im Anwendungsverzeichnis anzeigt:

      • docker-compose exec app ls -l

      Output

      total 260 -rw-rw-r-- 1 sammy sammy 737 Jun 9 11:19 Dockerfile -rw-rw-r-- 1 sammy sammy 101 Jan 7 08:05 README.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 app -rwxr-xr-x 1 sammy sammy 1686 Jan 7 08:05 artisan drwxrwxr-x 3 sammy sammy 4096 Jan 7 08:05 bootstrap -rw-rw-r-- 1 sammy sammy 1501 Jan 7 08:05 composer.json -rw-rw-r-- 1 sammy sammy 179071 Jan 7 08:05 composer.lock drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 config drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 database drwxrwxr-x 4 sammy sammy 4096 Jun 9 11:19 docker-compose -rw-rw-r-- 1 sammy sammy 965 Jun 9 11:27 docker-compose.yml -rw-rw-r-- 1 sammy sammy 1013 Jan 7 08:05 package.json -rw-rw-r-- 1 sammy sammy 1405 Jan 7 08:05 phpunit.xml drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 public -rw-rw-r-- 1 sammy sammy 273 Jan 7 08:05 readme.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 resources drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 routes -rw-rw-r-- 1 sammy sammy 563 Jan 7 08:05 server.php drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 storage drwxrwxr-x 4 sammy sammy 4096 Jan 7 08:05 tests drwxrwxr-x 41 sammy sammy 4096 Jun 9 11:32 vendor -rw-rw-r-- 1 sammy sammy 538 Jan 7 08:05 webpack.mix.js

      Jetzt führen wir composer install aus, um die Anwendungsabhängigkeiten zu installieren:

      • docker-compose exec app composer install

      Die Ausgabe sieht dann so aus:

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) - Installing erusev/parsedown (1.7.4): Downloading (100%) - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%) - Installing phpoption/phpoption (1.7.2): Downloading (100%) - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%) - Installing symfony/css-selector (v5.0.2): Downloading (100%) … Generating optimized autoload files > IlluminateFoundationComposerScripts::postAutoloadDump > @php artisan package:discover --ansi Discovered Package: facade/ignition Discovered Package: fideloper/proxy Discovered Package: laravel/tinker Discovered Package: nesbot/carbon Discovered Package: nunomaduro/collision Package manifest generated successfully.

      Als Letztes vor dem Anwendungstest verbleibt die Generierung eines eindeutigen Anwendungsschlüssels mit dem artisan Laravel-Tool auf Befehlszeilenebene. Dieser Schlüssel wird verwendet, um die Benutzersitzungen und andere sensible Daten zu verschlüsseln:

      • docker-compose exec app php artisan key:generate

      Output

      Application key set successfully.

      Gehen Sie jetzt in Ihren Browser und greifen Sie über Port 8000 auf den Domänenamen oder die IP-Adresse Ihres Servers zu:

      http://server_domain_or_IP:8000
      

      Anmerkung: Wenn Sie diese Demo auf Ihrem lokalen Rechner ausführen, verwenden Sie http://localhost:8000, um von Ihrem Browser aus auf die Anwendung zuzugreifen.

      Sie sehen in etwa folgende Seite:

      Demoversion der Laravel-Anwendung

      Sie können den Befehl logs verwenden, um die von den Diensten generierten Protokolle zu überprüfen:

      • docker-compose logs nginx
      Attaching to travellist-nginx
      …
      travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
      travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      

      Wenn Sie Ihre Docker-Compose-Umgebung unter Beibehaltung des Zustandes aller Dienste anhalten möchten, führen Sie Folgendes aus:

      Output

      Pausing travellist-db ... done Pausing travellist-nginx ... done Pausing travellist-app ... done

      So können Sie dann Ihre Dienste wiederaufnehmen:

      Output

      Unpausing travellist-app ... done Unpausing travellist-nginx ... done Unpausing travellist-db ... done

      Um Ihre Docker-Compose-Umgebung herunterzufahren und alle Container, Netzwerke und Volumes zu entfernen, führen Sie Folgendes aus:

      Output

      Stopping travellist-nginx ... done Stopping travellist-db ... done Stopping travellist-app ... done Removing travellist-nginx ... done Removing travellist-db ... done Removing travellist-app ... done Removing network travellist-laravel-demo_travellist

      Eine Übersicht aller Docker-Compose-Befehle finden Sie in der Docker Compose Befehlszeilenreferenz.

      Zusammenfassung

      In diesem Leitfaden haben wir mit Docker Compose eine Docker-Umgebung mit drei Containern eingerichtet, um eine Infrastruktur in einer YAML-Datei festzulegen.

      Ab jetzt können Sie in Ihrer Laravel-Anwendung arbeiten, ohne einen lokalen Webserver für die Entwicklung und Tests installieren und einrichten zu müssen. Außerdem arbeiten Sie mit einer löschbaren Testumgebung, die leicht repliziert und verteilt werden kann, was bei der Anwendungsentwicklung und auch beim Wechsel in eine Produktivumgebung hilfreich sein kann.



      Source link

      Installieren von Python 3 und Einrichten einer Programmierumgebung auf einem Ubuntu 20.04-Server


      Einführung

      Die Python-Programmiersprache ist eine zunehmend beliebte Wahl für Anfänger und auch erfahrene Entwickler. Python ist flexibel und vielseitig und bietet Vorteile in den Bereichen Skripterstellung, Automatisierung, Datenanalysen, maschinelles Lernen und Backend-Entwicklung. Python wurde 1991 erstmals veröffentlicht; der Name ist von der britischen Komikergruppe Monty Python inspiriert. Das Entwicklerteam wollte mit Python eine Sprache schaffen, deren Verwendung Spaß macht.

      In diesem Tutorial richten Sie Ihren Ubuntu 20.04-Server mit einer Python 3-Programmierumgebung ein. Das Programmieren auf einem Server bietet viele Vorteile und fördert die Zusammenarbeit bei Entwicklungsprojekten. Die allgemeinen Grundsätze dieses Tutorials gelten für alle Distributionen von Debian Linux.

      Voraussetzungen

      Um dieses Tutorial absolvieren zu können, benötigen Sie einen non-root user mit sudo-Berechtigungen auf einem Ubuntu 20.04-Server. Um zu erfahren, wie Sie diese Einrichtung erreichen, befolgen Sie unseren Leitfaden zur Ersteinrichtung des Servers.

      Wenn Sie noch nicht mit einer Terminalumgebung vertraut sind, können Sie im Artikel „Eine Einführung in das Linux-Terminal“ mehr über das Terminal erfahren.

      Nach der Einrichtung Ihres Servers und Benutzers können Sie loslegen.

      Schritt 1 — Einrichten von Python 3

      Ubuntu 20.04 und andere Versionen von Debian Linux werden mit vorinstalliertem Python 3 ausgeliefert. Um sicherzustellen, dass unsere Versionen aktuell sind, aktualisieren wir das System mit dem Befehl apt, um das Advanced Packaging Tool von Ubuntu zu nutzen:

      • sudo apt update
      • sudo apt -y upgrade

      Das Flag -y bestätigt, dass wir mit der Installation aller Elemente einverstanden sind. Je nach Ihrer Linux-Version müssen Sie aber ggf. zusätzliche Eingabeaufforderungen bei Aktualisierungen und Upgrades Ihres Systems bestätigen.

      Nach Abschluss des Verfahrens können wir die im System installierte Version von Python 3 überprüfen, indem wir Folgendes eingeben:

      Sie erhalten eine Ausgabe im Terminalfenster, in der die Versionsnummer steht. Zwar kann Ihre Zahl anders sein, die Ausgabe wird aber etwa wie folgt aussehen:

      Output

      Python 3.8.2

      Um Softwarepakete für Python zu verwalten, installieren wir pip, ein Tool, das Programmierpakete installieren und verwalten wird, die wir möglicherweise in unseren Entwicklungsprojekten verwenden möchten. Sie können mehr über Module oder Pakete erfahren, die Sie mit pip installieren können, indem Sie „Importieren von Modulen in Python 3“ lesen.

      • sudo apt install -y python3-pip

      Python-Pakete lassen sich installieren, indem Sie Folgendes eingeben:

      • pip3 install package_name

      Hier kann sich package_name auf beliebige Python-Pakete oder Bibliotheken beziehen, wie Django für die Webentwicklung oder NumPy für wissenschaftliches Rechnen. Wenn Sie NumPy installieren möchten, können Sie dies mit dem Befehl pip3 install numpy tun.

      Es sind noch einige weitere Pakete und Entwicklungstools zu installieren, um sicherzustellen, dass wir eine robuste Einrichtung für unsere Programmierumgebung haben:

      • sudo apt install -y build-essential libssl-dev libffi-dev python3-dev

      Nach der Einrichtung von Python und der Installation von pip und anderen Tools können wir eine virtuelle Umgebung für unsere Entwicklungsprojekte einrichten.

      Schritt 2 — Einrichten einer virtuellen Umgebung

      Mit virtuellen Umgebungen können Sie einen isolierten Bereich auf Ihrem Server für Python-Projekte schaffen, sodass jedes Ihrer Projekte einen eigenen Satz von Abhängigkeiten aufweist, der andere Projekte nicht stört.

      Das Einrichten einer Programmierumgebung bietet eine größere Kontrolle über Python-Projekte und die Handhabung verschiedener Versionen von Paketen. Das ist beim Einsatz von Paketen anderer Anbieter besonders wichtig.

      Sie können so viele Python-Programmierumgebungen einrichten wie nötig. Jede Umgebung ist im Grunde genommen ein Verzeichnis oder Ordner auf Ihrem Server, das bzw. der Skripte zum Ausführen einer Umgebung enthält.

      Es gibt zwar verschiedene Möglichkeiten, um eine Programmierumgebung in Python einzurichten, aber wir verwenden hier das Modul venv, das Teil der Standardbibliothek von Python 3 ist. Wir installieren venv, indem wir Folgendes eingeben:

      • sudo apt install -y python3-venv

      Nach der Installation sind wir bereit, Umgebungen zu erstellen. Wählen Sie entweder ein Verzeichnis, in das Sie Ihre Python-Programmierumgebungen einfügen möchten, oder erstellen Sie mit mkdir wie folgt ein neues Verzeichnis:

      • mkdir environments
      • cd environments

      Sobald Sie sich im Verzeichnis befinden, in dem Sie die Umgebungen einrichten möchten, können Sie eine Umgebung erstellen, indem Sie den folgenden Befehl ausführen:

      Im Grunde genommen richtet pyvenv ein neues Verzeichnis ein, das einige Elemente enthält, die wir mit dem Befehl ls anzeigen können:

      Output

      bin include lib lib64 pyvenv.cfg share

      Zusammen sorgen diese Dateien dafür, dass Ihre Projekte vom breiteren Kontext Ihres Servers isoliert werden, sodass sich Systemdateien und Projektdateien nicht vermischen. Dies ist eine gute Praxis für die Versionsverwaltung und sorgt dafür, dass jedes Ihrer Projekte Zugriff auf die jeweils benötigten Pakete hat. Python Wheels, ein für Python entwickeltes Paketformat, das Ihre Software-Produktion beschleunigen kann, indem es die Anzahl der benötigten Kompilierungen reduziert, wird sich im Verzeichnis share von Ubuntu 20.04 befinden.

      Um diese Umgebung zu verwenden, müssen Sie sie aktivieren. Das können Sie tun, indem Sie den folgenden Befehl eingeben, der das Skript activate aufruft:

      • source my_env/bin/activate

      Ihrer Eingabeaufforderung wird nun der Name Ihrer Umgebung vorangestellt. In diesem Fall heißt sie my_env. Je nach der Version von Debian Linux, die Sie ausführen, sieht Ihr Präfix möglicherweise etwas anders aus, der Name Ihrer Umgebung in Klammern sollte jedoch das Erste sein, das Sie in der Zeile sehen:

      Dieses Präfix lässt uns wissen, dass die Umgebung my_env gegenwärtig aktiv ist. Das bedeutet, dass bei der Erstellung von Programmen nur die Einstellungen und Pakete dieser spezifischen Umgebung verwendet werden.

      Anmerkung: Innerhalb der virtuellen Umgebung können Sie auf Wunsch den Befehl python anstelle von python3 und pip anstelle von pip3 verwenden. Wenn Sie Python 3 auf Ihrem Rechner außerhalb einer Umgebung verwenden, müssen Sie ausschließlich die Befehle python3 und pip3 verwenden.

      Nach den folgenden Schritten ist Ihre virtuelle Umgebung bereit zur Verwendung.

      Schritt 3 — Erstellen eines „Hello, World”-Programms

      Nachdem wir unsere virtuelle Umgebung eingerichtet haben, erstellen wir nun das traditionelle „Hello, World!“-Programm. Dadurch können wir unsere Umgebung testen und erhalten die Möglichkeit, uns mit Python besser vertraut zu machen, wenn wir es nicht bereits sind.

      Dazu öffnen wir einen Befehlszeilen-Texteditor wie nano und erstellen eine neue Datei:

      Sobald die Textdatei im Terminalfenster geöffnet ist, geben wir unser Programm ein:

      print("Hello, World!")
      

      Beenden Sie nano, indem Sie die Tasten STRG und X drücken. Wenn Sie zum Speichern der Datei aufgefordert werden, drücken Sie y.

      Sobald Sie nano beendet haben und zu Ihrer Shell zurückgekehrt sind, führen Sie das Programm aus:

      Das gerade erstellte Programm hello.py sollte dazu führen, dass im Terminal die folgende Ausgabe angezeigt wird:

      Output

      Hello, World!

      Geben Sie den Befehl deactivate ein, um die Umgebung zu verlassen und in das Originalverzeichnis zurückkehren.

      Zusammenfassung

      Herzlichen Glückwunsch! Sie haben auf Ihrem Ubuntu Linux-Server eine Python-3-Programmierumgebung eingerichtet und können nun mit einem Codierprojekt beginnen!

      Wenn Sie einen lokalen Rechner anstelle eines Servers verwenden, konsultieren Sie das Tutorial, das für Ihr Betriebssystem relevant ist, in unserer Reihe Installieren und Einrichten einer lokalen Programmierumgebung für Python 3.

      Da Ihr Server nun bereit für die Softwareentwicklung ist, können Sie mehr über das Codieren in Python erfahren, indem Sie unser kostenloses E-Book Codieren in Python 3 lesen oder unsere Python-Tutorials konsultieren.



      Source link

      Installieren von Python 3 und Einrichten einer Programmierumgebung unter Ubuntu 20.04 [Schnellstart]


      Einführung

      Python ist eine flexible und vielseitige Programmiersprache mit Stärken in den Bereichen Skripting, Automatisierung, Datenanalysen, maschinelles Lernen und Backend-Entwicklung.

      Dieses Tutorial führt Sie durch die Installation von Python und das Einrichten einer Programmierumgebung auf einem Ubuntu 20.04-Server. Eine ausführlichere Version dieses Tutorials mit genaueren Erklärungen zu den einzelnen Schritten finden Sie unter Installieren von Python 3 und Einrichten einer Programmierumgebung auf einem Ubuntu 20.04-Server.

      Schritt 1 — Aktualisieren und Upgraden

      Melden Sie sich als sudo Nicht-root-Benutzer bei Ihrem Ubuntu 20.04-Server an und führen Sie zuerst eine Aktualisierung und ein Upgrade Ihres Systems durch, um sicherzustellen, dass die bereitgestellte Version von Python 3 aktuell ist.

      • sudo apt update
      • sudo apt -y upgrade

      Bestätigen Sie die Installation, wenn Sie dazu aufgefordert werden.

      Schritt 2 — Prüfen der Version von Python

      Überprüfen Sie, welche Version von Python 3 installiert ist, indem Sie Folgendes eingeben:

      Sie erhalten eine Ausgabe, die der folgenden ähnelt, je nach dem, wann Sie Ihr System aktualisiert haben.

      Output

      Python 3.8.2

      Schritt 3 — Installieren von pip

      Um Softwarepakete für Python zu verwalten, installieren Sie pip, ein Tool, das Sie zur Verwaltung von Bibliotheken oder Modulen in Ihren Projekten verwenden können.

      • sudo apt install -y python3-pip

      Python-Pakete können installiert werden, indem Sie Folgendes eingeben:

      • pip3 install package_name

      Hier kann sich package_name auf beliebige Python-Pakete oder Bibliotheken beziehen, wie Django für die Webentwicklung oder NumPy für wissenschaftliches Rechnen. Wenn Sie NumPy installieren möchten, können Sie dies mit dem Befehl pip3 install numpy tun.

      Es gibt einige weitere Pakete und Entwicklungstools, die Ihnen dabei helfen, eine robuste Einrichtung für Ihre Programmierumgebung zu erreichen:

      • sudo apt install build-essential libssl-dev libffi-dev python3-dev

      Schritt 5 — Installieren von venv

      Virtuelle Umgebungen ermöglichen es Ihnen, für Python-Projekte einen isolierten Platz auf Ihrem Server einzurichten. Wir verwenden venv, ein Teil der standardmäßigen Python 3-Bibliothek, das wir installieren können, indem wir Folgendes eingeben:

      • sudo apt install -y python3-venv

      Schritt 6 — Erstellen einer virtuellen Umgebung

      Sie können mit dem Befehl pyvenv eine neue Umgebung erstellen. Hier nennen wir unsere neue Umgebung my_env, aber Sie sollten Ihrer Umgebung einen aussagekräftigen Namen geben.

      Schritt 7 — Aktivieren der virtuellen Umgebung

      Aktivieren Sie die Umgebung mit dem folgenden Befehl, wobei my_env der Name Ihrer Programmierumgebung ist.

      • source my_env/bin/activate

      Ihrer Befehlsaufforderung wird nun der Name Ihrer Umgebung vorangestellt:

      Schritt 8 — Testen der virtuellen Umgebung

      Öffnen Sie den Python-Interpreter:

      Beachten Sie, dass Sie innerhalb der virtuellen Python 3-Umgebung den Befehl python anstelle von python3 und pip anstelle von pip3 verwenden können.

      Sie wissen, dass Sie sich im Interpreter befinden, wenn Sie die folgende Ausgabe erhalten:

      Python 3.8.2 (default, Mar 13 2020, 10:14:16)
      [GCC 9.3.0] on linux
      Type "help", "copyright", "credits" or "license" for more information.
      >>>
      

      Verwenden Sie nun die Funktion print(), um das traditionelle „Hello, World“-Programm zu erstellen:

      Output

      Hello, World!

      Schritt 9 — Deaktivieren der virtuellen Umgebung

      Beenden Sie den Python-Interpreter:

      Beenden Sie dann die virtuelle Umgebung:

      Weiteres Lesematerial

      Jetzt sind Sie bereit, um viel über Python zu lernen; hier sind Links, die thematisch mit dem Leitfaden verwandt sind:



      Source link