One place for hosting & domains

      Como Criar Ambientes de Desenvolvimento PHP com o Docker Compose


      This Tech Talk will be streaming live on Thursday, July 9, 2020, 12:00–1:00 p.m. GMT-3.
      RSVP for free on Eventbrite here.

      Sobre a Palestra

      Com a popularização de micro serviços e sistemas distribuídos, contêineres tornaram-se uma opção bastante popular para ambientes de desenvolvimento, possibilitando a criação de ambientes que são leves e descartáveis, e podem ser facilmente replicados e distribuídos. O Docker Compose foi criado para facilitar a operação de ambientes que utilizam múltiplos contêineres, como é o caso da pilha LEMP padrão.

      Esta palestra irá demonstrar como criar um ambiente de desenvolvimento com o Docker Compose, usando uma aplicação Laravel como caso de estudo. Veremos como definir e integrar serviços, como compartilhar arquivos entre contêineres, e como administrar o seu ambiente usando comandos do Docker Compose.

      Principais Tópicos

      • Como criar um arquivo docker-compose.yml e configurar serviços
      • Principais comandos do Docker Compose

      Público Alvo

      Desenvolvedores PHP que buscam trabalhar com contêineres e ambientes de desenvolvimento baseados no Docker.

      Pré-requisitos

      Familiaridade com a pilha LEMP e ambientes de desenvolvimento PHP em geral.

      Sobre a Palestrante

      Erika Heidi é uma engenheira de software e devOps trabalhando como produtora de conteúdo técnico para a DigitalOcean. Entusiasta do Linux e do código aberto, Erika está sempre procurando novas formas de compartilhar conteúdo que ajude a reduzir as barreiras de entrada a novas tecnologias.

      Como Participar

      This Tech Talk is free and open to everyone. Join the live event on Thursday, July 9, 2020, 12:00–1:00 p.m. GMT-3 by registering on Eventbrite here and Erika will be answering questions at the end.



      Source link

      How To Run Multiple PHP Versions on One Server Using Apache and PHP-FPM on Ubuntu 20.04


      Not using Ubuntu 20.04?


      Choose a different version or distribution.

      The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      The Apache web server uses virtual hosts to manage multiple domains on a single instance. Similarly, PHP-FPM uses a daemon to manage multiple PHP versions on a single instance. Together, you can use Apache and PHP-FPM to host multiple PHP web-applications, each using a different version of PHP, all on the same server, and all at the same time. This is useful because different applications may require different versions of PHP, but some server stacks, like a regularly configured LAMP stack, can only manage one. Combining Apache with PHP-FPM is also a more cost-efficient solution than hosting each application on its own instance.

      PHP-FPM also offers configuration options for stderr and stdout logging, emergency restarts, and adaptive process spawning, which is useful for heavy-loaded sites. In fact, using Apache with PHP-FPM is one of the best stacks for hosting PHP applications, especially when it comes to performance.

      In fact, using Apache with PHP-FPM is one of the best stacks for hosting PHP applications, especially when it comes to performance. PHP-FPM not only allows you run to multiple PHP versions simultaneously, it also provides numerous extra features like adaptive process spawning, which is useful for heavy-loaded sites.

      In this tutorial you will set up two PHP sites on a single instance. Each site will use its own domain, and each domain will deploy its own version of PHP. The first, site1.your_domain, will deploy PHP 7.2. The second, site2.your_domain, will deploy PHP 7.3.

      Prerequisites

      Step 1 — Installing PHP Versions 7.2 and 7.3 with PHP-FPM

      With the prerequisites completed, you will now install PHP versions 7.2 and 7.3, as well as PHP-FPM and several additional extensions. But to accomplish this, you will first need to add the Ondrej PHP repository to your system.

      Execute the apt-get command to install software-properties-common:

      • sudo apt-get install software-properties-common -y

      The software-properties-common package provides apt-add-repository command-line utility which you will use to add the ondrej/php PPA (Personal Package Archive) repository.

      Now add the ondrej/php repository to your system. The ondrej/php PPA will have more up-to-date versions of PHP than the official Ubuntu repositories, and it will also allow you to install multiple versions of PHP in the same system:

      • sudo add-apt-repository ppa:ondrej/php

      Update the repository:

      Next, install php7.2, php7.2-fpm, php7.2-mysql, libapache2-mod-php7.2, and libapache2-mod-fcgid with the following commands:

      • sudo apt-get install php7.2 php7.2-fpm php7.2-mysql libapache2-mod-php7.2 libapache2-mod-fcgid -y
      • php7.2 is a metapackage used to run PHP applications.
      • php7.2-fpm provides the Fast Process Manager interpreter that runs as a daemon and receives Fast/CGI requests.
      • php7.2-mysql connects PHP to the MySQL database.
      • libapache2-mod-php7.2 provides the PHP module for the Apache webserver.
      • libapache2-mod-fcgid contains a mod_fcgid that starts a number of CGI program instances to handle concurrent requests.

      Now repeat the process for PHP version 7.3. Install php7.3, php7.3-fpm, php7.3-mysql, and libapache2-mod-php7.3.

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

      After installing both PHP versions, start the php7.2-fpm service:

      • sudo systemctl start php7.2-fpm

      Next, verify the status of php7.2-fpm service:

      • sudo systemctl status php7.2-fpm

      You’ll see the following output:

      Output

      • ● php7.2-fpm.service - The PHP 7.2 FastCGI Process Manager
      • Loaded: loaded (/lib/systemd/system/php7.2-fpm.service; enabled; vendor preset: enabled)
      • Active: active (running) since Fri 2020-06-05 11:25:07 UTC; 1min 38s ago
      • Docs: man:php-fpm7.2(8)
      • Main PID: 13703 (php-fpm7.2)
      • Status: "Processes active: 0, idle: 2, Requests: 0, slow: 0, Traffic: 0req/sec"
      • Tasks: 3 (limit: 2353)
      • Memory: 6.2M
      • CGroup: /system.slice/php7.2-fpm.service
      • ├─13703 php-fpm: master process (/etc/php/7.2/fpm/php-fpm.conf)
      • ├─13719 php-fpm: pool www
      • └─13720 php-fpm: pool www
      • Jun 05 11:25:07 ubuntu systemd[1]: Starting The PHP 7.2 FastCGI Process Manager...
      • Jun 05 11:25:07 ubuntu systemd[1]: Started The PHP 7.2 FastCGI Process Manager.

      Repeating this process, now start the php7.3-fpm service:

      • sudo systemctl start php7.3-fpm

      Next, verify the status of php7.3-fpm service:

      • sudo systemctl status php7.3-fpm

      You’ll see the following output:

      Output

      • ● php7.3-fpm.service - The PHP 7.3 FastCGI Process Manager
      • Loaded: loaded (/lib/systemd/system/php7.3-fpm.service; enabled; vendor preset: enabled)
      • Active: active (running) since Fri 2020-06-05 11:26:33 UTC; 56s ago
      • Docs: man:php-fpm7.3(8)
      • Process: 23470 ExecStartPost=/usr/lib/php/php-fpm-socket-helper install /run/php/php-fpm.sock /etc/php/7.3/fpm/pool.d/www.conf 73 (code=ex>
      • Main PID: 23452 (php-fpm7.3)
      • Status: "Processes active: 0, idle: 2, Requests: 0, slow: 0, Traffic: 0req/sec"
      • Tasks: 3 (limit: 2353)
      • Memory: 7.1M
      • CGroup: /system.slice/php7.3-fpm.service
      • ├─23452 php-fpm: master process (/etc/php/7.3/fpm/php-fpm.conf)
      • ├─23468 php-fpm: pool www
      • └─23469 php-fpm: pool www
      • Jun 05 11:26:33 ubuntu systemd[1]: Starting The PHP 7.3 FastCGI Process Manager...
      • Jun 05 11:26:33 ubuntu systemd[1]: Started The PHP 7.3 FastCGI Process Manager.

      Lastly, you must enable several modules so that your Apache2 service can work with multiple PHP versions:

      • sudo a2enmod actions fcgid alias proxy_fcgi
      • actions is used for executing CGI scripts based on media type or request method.

      • fcgid is a high performance alternative to mod_cgi that starts a sufficient number of instances of the CGI program to handle concurrent requests.

      • alias provides for the mapping of different parts of the host filesystem in the document tree, and for URL redirection.

      • proxy_fcgi allows Apache to forward requests to PHP-FPM.

      Now restart the Apache service to apply your changes:

      • sudo systemctl restart apache2

      At this point you have installed two PHP versions on your server. Next, you will create a directory structure for each website you want to deploy.

      Step 2 — Creating Directory Structures for Both Websites

      In this section, you will create a document root directory and an index page for each of your two websites.

      First, create document root directories for both site1.your_domain and site2.your_domain:

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

      By default, the Apache webserver runs as a www-data user and www-data group. To ensure that you have the correct ownership and permissions of your website root directories, execute the following commands:

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

      Next you will create an info.php file inside each website root directory. This will display each website’s PHP version information. Begin with site1:

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

      Add the following line:

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

      <?php phpinfo(); ?>
      

      Save and close the file. Now copy the info.php file you created to site2:

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

      Your web server should now have the document root directories that each site requires to serve data to visitors. Next, you will configure your Apache web server to work with two different PHP versions.

      Step 3 — Configuring Apache for Both Websites

      In this section, you will create two virtual host configuration files. This will enable your two websites to work simultaneously with two different PHP versions.

      In order for Apache to serve this content, it is necessary to create a virtual host file with the correct directives. Instead of modifying the default configuration file located at /etc/apache2/sites-available/000-default.conf, you’ll create two new ones inside the directory /etc/apache2/sites-available/.

      First create a new virtual host configuration file for the website site1.your_domain. Here you will direct Apache to render content using php7.2:

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

      Add the following content. Make sure the website directory path, server name, and PHP version match your setup:

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

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

      In this file you updated the DocumentRoot to your new directory and ServerAdmin to an email that the your_domain site administrator can access. You’ve also updated ServerName, which establishes the base domain for this virtual host configuration, and you’ve added a SetHandler directive to run PHP as a fastCGI process server.

      Save and close the file.

      Next, create a new virtual host configuration file for the website site2.your_domain. You will specify this subdomain to deploy php7.3:

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

      Add the following content. Again, make sure the website directory path, server name, and PHP version match your unique information:

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

      <VirtualHost *:80>
           ServerAdmin admin@site2.your_domain
           ServerName site2.your_domain
           DocumentRoot /var/www/site2.your_domain
           DirectoryIndex info.php
      
           <Directory /var/www/site2.your_domain>
              Options Indexes FollowSymLinks MultiViews
              AllowOverride All
              Order allow,deny
              allow from all
           </Directory>
      
          <FilesMatch .php$>
              # 2.4.10+ can proxy to unix socket
               SetHandler "proxy:unix:/run/php/php7.3-fpm.sock|fcgi://localhost"
          </FilesMatch>
      
           ErrorLog ${APACHE_LOG_DIR}/site2.your_domain_error.log
           CustomLog ${APACHE_LOG_DIR}/site2.your_domain_access.log combined
      </VirtualHost>
      

      Save and close the file when you are finished. Then, check the Apache configuration file for any syntax errors:

      • sudo apachectl configtest

      You’ll see the following output:

      Output

      Next, enable both virtual host configuration files with the following commands:

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

      Now disable the default site, since you won’t need it.:

      • sudo a2dissite 000-default.conf

      Finally, restart the Apache service to implement your changes:

      • sudo systemctl restart apache2

      Now that you have configured Apache to serve each site, you will test them to make sure the proper PHP versions are running.

      Step 4 — Testing Both Websites

      At this point, you have configured two websites to run two different versions of PHP. Now test the results.

      Open your web browser and visit both sites http://site1.your_domain and http://site2.your_domain. You will see two pages that look like this:

      PHP 7.2 info page
      PHP 7.3 info page

      Note the titles. The first page indicates that site1.your_domain deployed PHP version 7.2. The second indicates that site2.your_domain deployed PHP version 7.3.

      Now that you’ve tested your sites, remove the info.php files. Because they contain sensitive information about your server and are accessible to unauthorized users, they pose a security vulnerability. To remove both files, run the following commands:

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

      You now have a single Ubuntu 20.04 server handling two websites with two different PHP versions. PHP-FPM, however, is not limited to this one application.

      Conclusion

      You have now combined virtual hosts and PHP-FPM to serve multiple websites and multiple versions of PHP on a single server. The only practical limit on the number of PHP sites and PHP versions that your Apache service can handle is the processing power of your instance.

      From here you might consider exploring PHP-FPM’s more advanced features, like its adaptive spawning process or how it can log sdtout and stderr Alternatively, you could now secure your websites. To accomplish this, you can follow our tutorial on how to secure your sites with free TLS/SSL certificates from Let’s Encrypt.



      Source link

      So installieren Sie Linux, Nginx, MySQL und PHP (LEMP-Stack) unter Ubuntu 20.04 [Schnellstart]


      Einführung

      In diesem Schnellstartleitfaden installieren wir einen LEMP-Stack auf einem Ubuntu 20.04-Server.

      Eine detailliertere Version dieses Tutorials mit weiteren Erklärungen zu einzelnen Schritten finden Sie unter Installieren des Linux-, Nginx-, MySQL-, PHP- (LEMP-)Stacks unter Ubuntu 20.04.

      Voraussetzungen

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

      Schritt 1 – Installation von Nginx

      Aktualisieren Sie den Cache Ihres Paketmanagers und installieren Sie dann Nginx mit:

      • sudo apt update
      • sudo apt install nginx

      Sobald die Installation abgeschlossen ist, müssen Sie Ihre Firewalleinstellungen so anpassen, dass HTTP-Verkehr auf Ihrem Server zugelassen wird. Führen Sie den folgenden Befehl aus, um externen Zugriff an Port 80 (HTTP): zu ermöglichen

      • sudo ufw allow in "Nginx"

      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:

      Nginx-Standardseite

      Schritt 2 — Installieren von MySQL

      Wir installieren jetzt MySQL, ein beliebtes Datenbankverwaltungssystem, das in PHP-Umgebungen verwendet wird.

      Verwenden Sie auch hier wieder apt zur Beschaffung und Installation der Software:

      • sudo apt install mysql-server

      Sobald die Installation abgeschlossen ist, empfehlen wir, ein Sicherheitsskript auszuführen, das in MySQL vorinstalliert ist. Starten Sie das interaktive Skript, indem Sie Folgendes ausführen:

      • sudo mysql_secure_installation

      Sie werden gefragt, ob Sie das VALIDATE PASSWORD PLUGIN konfigurieren möchten. Geben Sie Y für Ja oder etwas Anderes ein, um ohne Aktivierung weiterzumachen. Wenn Sie mit „ja“ antworten, werden Sie dazu aufgefordert, eine Stufe der Passwortvalidierung zu wählen.

      Ihr Server fordert Sie als Nächstes dazu auf, ein Passwort für den MySQL root-Benutzer auszuwählen und zu bestätigen. Zwar entbindet die Standardauthentifizierungsmethode für den MySQL root-Benutzer von der Verwendung eines Passworts, selbst wenn eines festgelegt ist, doch sollten Sie hier als zusätzliche Sicherheitsmaßnahme ein starkes Passwort definieren.

      Drücken Sie bei den restlichen Fragen auf Y und bei jeder Eingabeaufforderung ENTER.

      Anmerkung: Zum Zeitpunkt der Verfassung dieses Dokuments unterstützt die native MySQL-PHP-Bibliothek mysqlnd keine caching_sha2_authentication, die standardmäßige Authentifizierungsmethode für MySQL 8. Wenn Sie Datenbankbenutzer für PHP-Anwendungen unter MySQL 8 erstellen, müssen Sie sie daher so konfigurieren, dass sie stattdessen mysql_native_password verwenden. Konsultieren Sie den Schritt 6 unseres detaillierten Leitfadens für LEMP unter Ubuntu 20.04, um mehr zu erfahren.

      Schritt 3 — Installieren von PHP

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

      • sudo apt install php-fpm php-mysql

      Schritt 4 – Konfigurieren von Nginx für PHP

      In diesem Leitfaden richten wir eine Domäne namens your_domain ein, aber Sie sollten diesen Namen durch Ihren eigenen Domänenamen ersetzen.

      Auf Ubuntu 20.04 hat Nginx einen Serverblock standardmäßig aktiviert und ist so konfiguriert, das Dokumente aus einem Verzeichnis in /var/www/html bereitgestellt werden. Das eignet sich gut für eine Website, kann aber umständlich werden, wenn Sie mehrere hosten. Statt /var/www/html zu ändern, erstellen wir eine Verzeichnisstruktur innerhalb von /var/www für die Website your_domain und belassen dabei /var/www/html als Standardverzeichnis, das genutzt wird, wenn eine Clientanfrage keine übereinstimmenden Websites ergibt.

      Erstellen Sie das Root-Webverzeichnis für your_domain wie folgt:

      • sudo mkdir /var/www/your_domain

      Als Nächstes weisen Sie die Eigentumsrechte des Verzeichnisses mit der Umgebungsvariablen $USER zu, die auf Ihren aktuellen Systembenutzer verweisen wird:

      • sudo chown -R $USER:$USER /var/www/your_domain

      Öffnen Sie dann mit Ihrem bevorzugten Befehlszeileneditor eine neue Konfigurationsdatei im Verzeichnis sites-available von Nginx. Wir verwenden hier nano:

      • sudo nano /etc/nginx/sites-available/your_domain

      Dadurch wird eine neue Leerdatei erstellt. Fügen Sie die folgende Basiskonfiguration ein:

      /etc/nginx/sites-available/your_domain

      server {
          listen 80;
          server_name your_domain www.your_domain;
          root /var/www/your_domain;
      
          index index.html index.htm index.php;
      
          location / {
              try_files $uri $uri/ =404;
          }
      
          location ~ .php$ {
              include snippets/fastcgi-php.conf;
              fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
           }
      
          location ~ /.ht {
              deny all;
          }
      
      }
      
      
      

      Wenn Sie mit der Bearbeitung fertig sind, speichern und schließen Sie die Datei. Wenn Sie nano verwenden, können Sie zur Bestätigung STRG+X und dann y und ENTER eingeben.

      Aktivieren Sie Ihre Konfiguration, indem Sie eine Verknüpfung mit der Konfigurationsdatei aus dem sites-enabled-Verzeichnis von Nginx herstellen:

      • sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/

      Dadurch wird Nginx angewiesen, die Konfiguration beim nächsten Neuladen zu verwenden. Sie können Ihre Konfiguration auf Syntaxfehler testen, indem Sie Folgendes eingeben:

      Wenn Fehler gemeldet werden, gehen Sie zurück zu Ihrer Konfigurationsdatei, um den Inhalt vor dem Fortfahren zu überprüfen.

      Wenn Sie fertig sind, laden Sie Nginx neu, um die Änderungen anzuwenden:

      • sudo systemctl reload nginx

      Ihre neue Website ist nun aktiv, aber die Web-root /var/www/your_domain ist immer noch leer. Erstellen Sie an diesem Ort eine index.html-Datei, um zu testen, ob Ihr neuer Serverblock wie erwartet funktioniert:

      • nano /var/www/your_domain/index.html

      Fügen Sie in dieser Datei folgende Inhalte ein:

      /var/www/your_domain/index.html

      <html>
        <head>
          <title>your_domain website</title>
        </head>
        <body>
          <h1>Hello World!</h1>
      
          <p>This is the landing page of <strong>your_domain</strong>.</p>
        </body>
      </html>
      

      Gehen Sie nun zu Ihrem Browser und greifen Sie auf den Domänennamen oder die IP-Adresse Ihres Servers zu, wie sie in der server_name-Anweisung in Ihrer Serverblock-Konfigurationsdatei aufgeführt sind:

      http://server_domain_or_IP
      

      Sie sehen in etwa folgende Seite:

      Nginx Serverblock

      Schritt 5 – Testen von PHP mit Nginx

      Wir erstellen jetzt ein PHP-Testskript, um zu prüfen, ob Nginx Anfragen für PHP-Dateien bearbeiten kann.

      Erstellen Sie eine neue Datei namens info.php in Ihrem benutzerdefinierten Web-root-Ordner:

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

      Damit wird eine leere Datei geöffnet. Fügen Sie in der Datei folgenden Inhalt hinzu:

      /var/www/your_domain/info.php

      <?php
      phpinfo();
      

      Wenn Sie dies abgeschlossen haben, speichern und schließen Sie die Datei.

      Sie können nun in Ihrem Webbrowser auf diese Seite zugreifen, indem Sie den Domänennamen oder die öffentliche IP-Adresse besuchen, die Sie in Ihrer Nginx-Konfigurationsdatei eingerichtet haben, gefolgt von /info.php:

      http://server_domain_or_IP/info.php
      

      Sie sehen dann eine Webseite, die detaillierte Informationen über Ihren Server enthält:

      PHPInfo Ubuntu 20.04

      Nachdem Sie über diese Seite die relevanten Informationen zu Ihrem PHP-Server überprüft haben, ist es am besten, die von Ihnen erstellte Datei zu entfernen, da sie sensible Informationen über Ihre PHP-Umgebung und Ihren Ubuntu-Server enthält. Sie können rm verwenden, um diese Datei zu entfernen:

      • sudo rm /var/www/your_domain/info.php

      Relevante Tutorials

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



      Source link