The core role of Homebrew in the construction of Mac environment is to simplify software installation and management. 1. Homebrew automatically handles dependencies and encapsulates complex compilation and installation processes into simple commands; 2. Provides a unified software package ecosystem to ensure the standardization of software installation location and configuration; 3. Integrates service management functions, and can easily start and stop services through brew services; 4. Convenient software upgrade and maintenance, and improves system security and functionality.

Building a PHP Nginx environment on a Mac is actually to use Homebrew, a powerful package manager, to install and configure Nginx as a web server, and at the same time, let PHP-FPM (PHP FastCGI Process Manager) process PHP scripts. The two work together through the FastCGI protocol. This combination is both efficient and flexible for the local development environment.

To talk about the solution, this is probably the idea:

You must first make sure that your Mac has Homebrew, which is simply the Swiss Army Knife of Mac developers. If not, run a sentence in the terminal: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" Install Homebrew, and we can start to invite Nginx and PHP to settle in.

Install Nginx: brew install nginx command and Nginx will be obediently lying in your system. Its default configuration file path is usually in /usr/local/etc/nginx/nginx.conf .

Install PHP (I am used to installing the latest stable version, such as PHP 8.2 or 8.3, depending on your project requirements): brew install php or if you need a specific version: brew install php@8.2 After the installation is completed, Homebrew will tell you where the PHP-FPM configuration file is, usually /usr/local/etc/php/8.2/php-fpm.d/www.conf (the path will vary depending on the PHP version).

Nginx configuration is core. You need to edit nginx.conf . Find server block in http block, or create a new one yourself. A typical configuration looks like this:

 http {
    # ...Other configurations...

    server {
        listen 8080; # or any port you like to avoid conflicts with other services in the system server_name localhost; # or your local domain name root /Users/your_username/Sites; # This is the directory where you store the website files. Remember to replace it with your own path index index.php index.html index.htm;

        location / {
            try_files $uri $uri/ /index.php?$query_string;
        }

        # This is the key part, let Nginx forward PHP requests to PHP-FPM
        location ~ \.php$ {
            # Check whether the file exists and avoid Nginx processing of non-existent PHP files try_files $uri =404;
            # FastCGI server address, usually the default socket of PHP-FPM
            fastcgi_pass 127.0.0.1:9000; # or unix:/usr/local/var/run/php-fpm.sock
            # Introduce FastCGI parameters include fastcgi_params;
            # Set SCRIPT_FILENAME to tell PHP-FPM the script path currently executed fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            # Allow Nginx to pass HTTP authentication header fastcgi_param PATH_INFO $fastcgi_path_info;
        }

        # Hide .ht* files to prevent sensitive information leakage location ~ /\.ht {
            deny all;
        }
    }
}

Note fastcgi_pass line. If PHP-FPM listens to TCP port 9000 by default, use 127.0.0.1:9000 ; if it listens to Unix socket, the path will be like /usr/local/var/run/php-fpm.sock (this path can be found in PHP-FPM www.conf ). I personally prefer to use Unix sockets, which have a slight performance advantage and avoid the possibility of port conflicts.

For PHP-FPM configuration, you usually don’t need to move too much. Just make sure that the listen parameter in www.conf matches the address of fastcgi_pass in Nginx configuration. The PHP-FPM installed by default Homebrew is usually already configured.

Start the service: Start Nginx: brew services start nginx Start PHP-FPM: brew services start php (or brew services start php@8.2 corresponds to the version you installed)

Test it out: Create an index.php file in the root directory of your website (such as /Users/your_username/Sites I configured above), with the content of <?php phpinfo(); ?> . Then open the browser to visit http://localhost:8080/index.php (or the port and domain name you configured). If you see the familiar PHP information page, then congratulations, the environment is ready.

What is the core role of Homebrew in building a Mac environment?

When it comes to the development environment on Mac, Homebrew is really something that makes people love and hate, but more about love. Its core function is to turn the software that might have required you to manually download, compile and configure it into a line of simple commands. Imagine that without Homebrew, if you want to install Nginx, you may have to download the source code on the official website, decompress it, and then ./configure , make , make install . During the process, you will encounter various dependency problems and your head is too big. Homebrew is like a super diligent butler, helping you with all these tedious tasks.

The best thing about it is that it provides a unified and easy-to-manage software package ecosystem. What do you want to install? brew install it will help you handle all dependencies, install it to the correct location, and usually it will help you configure startup scripts, such as Nginx and PHP-FPM, and you can run by brew services start . This convenience is simply a powerful tool for developers to improve productivity. It makes the Mac's command line environment more friendly and powerful, allowing us to focus more on the code itself rather than the quagmire of environment construction. Moreover, upgrading the software is also simple, brew upgrade , and all software installed through Homebrew can be kept up to date, which is very beneficial in terms of security and functionality.

How does Nginx work together with PHP-FPM?

The collaboration between Nginx and PHP-FPM is a very exquisite design in the entire PHP Web service architecture. Simply put, Nginx is a "facade", while PHP-FPM is a "behind the scenes".

When the user enters a URL in the browser, such as http://localhost:8080/index.php , the request first reaches Nginx. Nginx is an efficient static file server. If you request static resources such as pictures, CSS, and JS, it will be read directly from the file system and returned to the browser, with a very fast speed. But if the requested .php file, Nginx will know that it cannot handle this matter itself, and it needs PHP to handle it.

At this time, Nginx will not directly execute PHP code, but will play the role of a "forwarder". It forwards this PHP request to PHP-FPM through the FastCGI protocol. PHP-FPM is a process manager of PHP that maintains one or more PHP interpreter process pools. When Nginx throws the request over, PHP-FPM will find an idle PHP process from its process pool to handle the request. After this PHP process receives the request, it will parse the corresponding .php file, execute the PHP code inside, and may connect to the database, process business logic, etc.

After the PHP code is executed, PHP-FPM will return the execution result (usually HTML, JSON, or other data) to Nginx through the FastCGI protocol. After Nginx gets this result, it finally sends it to the user's browser.

The benefits of this separation design are obvious: Nginx focuses on efficiently handling HTTP requests and static files, while PHP-FPM focuses on parsing and executing PHP code. Both perform their own duties and do not interfere with each other, greatly improving the stability and performance of the entire system. For example, even if the PHP process crashes, Nginx can still run normally, but it cannot handle PHP requests, which will not cause the entire web service to go down.

Common Nginx and PHP configuration traps and solutions in Mac environments

Configuring Nginx and PHP on Mac, although Homebrew has greatly simplified the process, it is still easy to get stuck in some places. I have personally encountered many. To sum up, there are probably a few common traps and corresponding solutions:

1. Port conflict problem: Nginx will listen to port 80 by default, but if your Mac already has Apache (comed with macOS) or other services occupy port 80, Nginx will not be started.

• Solution: The most direct way is to modify the Nginx configuration to let it listen for an infrequently used port, such as 8080, 8000 or 8888. Just modify listen instruction in server block of nginx.conf . Or, if you are sure you don't need Apache, you can disable it: sudo apachectl stop .

2. File permission issues: Nginx or PHP-FPM cannot read your website files, or PHP cannot write to logs or cache files. This is especially common on Macs, because user permissions and file system permissions are sometimes subtle.

• Solution strategy:
  • Make sure that the root directory of your website (the directory pointed to by the root directive) and the files and folders in it, users running Nginx (usually _www or nobody ) have read permissions.
  • For directories (such as logs, caches) that PHP needs to write to, ensure that users running PHP-FPM have write permissions. The easiest rough way is chmod -R 777 , but that's not the best practice. A safer way is chown -R _www:_www /path/to/your/project , then chmod -R 755 /path/to/your/project and chmod -R 775 /path/to/your/project/cache_or_log_dir .

3. PHP-FPM is not running or configuration mismatched: Nginx has fastcgi_pass configured, but PHP-FPM is not started, or the FastCGI address (port or socket path) pointed to by Nginx is inconsistent with the actual listening of PHP-FPM.

• Solution strategy:
  • Confirm whether PHP-FPM has been started: brew services list to see if the status of php or php@版本號is started . If not, brew services start php .
  • Check the PHP-FPM configuration file (usually in /usr/local/etc/php/版本號/php-fpm.d/www.conf ), find the listen directive, confirm whether it is listening to the TCP port ( 127.0.0.1:9000 ) or a Unix socket ( listen = /usr/local/var/run/php-fpm.sock ). Then make sure that fastcgi_pass in the Nginx configuration matches it exactly.

4. Nginx configuration syntax error: Nginx configuration is very strict. A small semicolon missed or the brackets mismatch will cause Nginx to fail to start.

• Solution strategy: After modifying Nginx configuration, you should first use the nginx -t command to test whether the syntax of the configuration file is correct. If syntax is ok and test is successful , you can restart Nginx with confidence.

5. root path or index file configuration error: Nginx cannot find your website file, or index.php cannot be found.

• Solution: Double check whether the path pointed to by the root directive in nginx.conf is correct, and make sure that index directive contains index.php and the order is correct.

When you encounter problems, the first step is always to check Nginx's error logs (usually in /usr/local/var/log/nginx/error.log ) and PHP-FPM's logs. These log files will tell you what's wrong, is it because of insufficient permissions, port conflicts, or a PHP code error. Experience tells me that logging is the best guide to solving problems.

The above is the detailed content of How to build a PHP Nginx environment with MacOS to configure the combination of Nginx and PHP services. For more information, please follow other related articles on the PHP Chinese website!