Maximizing the application - PHP

When we are programming, regardless of language, there are concepts and techniques that we can adopt to improve both code readability and understanding and application performance.

The greatest learning here is: Do not try to reinvent the wheel . As I always say: study and research. Most likely, someone has already faced the same problem as you and found an efficient solution. Taking advantage of the knowledge accumulated by the community not only saves time, but also helps to avoid traps and common errors.

Queries and Database

On this subject, which is very important in applications, I already wrote a little, it is worth a read.

Optimizing Data Persistence and Reading on MySQL and Application

Performance Optimization Techniques

In addition to databases and databases, there are other fundamental areas for optimizing applications. Let's highlight some:

cache The use of cache is essential to reduce the load in the database, temporarily storing data that is frequently accessed. The community widely uses
Maximizing the application - PHP for this purpose.

Redis is a highly performative but volatile Nosql database in memory as memory is not persistent. It is ideal for cases such as:

real -time consumption data
User Sessions
Purchase carts

Laravel abstracts the use of Redis for both cache and other purposes. However, use it with caution! Perform many tests and learn about FAILOVER techniques to deal with possible unavailability. For example, if your dashboard in real time depends on Redis, what will you do if it gets inoperative? Planning alternatives is crucial.

Code optimizations

Some important points when we talk about code writing optimization:

• Loops: Not always replacing for Foreach will improve performance. Although the code may become more readable, it is essential to test using tools such as * xdebug * or simple functions as microtime () to validate the actual impact. Pay attention to data manipulation within the loop and avoid memory waste.

• Native operations: Using native PHP functions such as array_map is usually safer and more efficient than creating custom solutions. Remember, "No need to reinvent the wheel."

• Minimize loop operations: Avoid creating loops within loops unnecessarily. An nestled forech can be as harmful as a select *. Instead, consider alternative solutions, such as rewriting logic or using more efficient queries to reduce complexity.

• PSR (PHP Standards Recommendations) : Adhering to PSR practices improves code readability and maintenance. Today, IDES offer extensions that automate the application of these standards by saving changes. Not only does this help in the quality of the code, but it also makes life easier for those who will maintain the future

• Queues: The use of queues is increasingly common. The idea is simple: if the processing of a task can be done later, remove it from the immediate execution of the method.
  Example :
  When a user makes a purchase in e-commerce, is it necessary to send the e-mail confirmation instantly? Many times, no. In this case, you can send the email to a queue, which will be processed in lots, saving resources and ensuring scalability.

Subprocesses : It is not silver bullet, but depending on the situation can be implemented and it is worth it.
Example :
Imagine an application responsible for processing hundreds of invoices simultaneously, calculating taxes for each. If all these operations are performed in a sequence, you may face slow alerts, even with computational resources left (CPU and RAM).
In this case, subprocesses can be a solution. Divide processing into small parts and run them in parallel. For example, each subprocess may be responsible for calculating taxes for a group of invoices. This allows your application to better enjoy available resources, accelerate processing and avoid bottlenecks.

• Requires and includes : Prefer the use of AutoLovement to manage class and file loading. This not only improves performance, it avoids problems with large and unnecessary classes (the famous megazords). For example, loading a class with 7,000 lines just to use a select method is extremely inefficient. In these situations, it is important to consider a refactor .

About Megazord, it is worth a chat about refactoring.

Server Optimizations

The first thing you need to know is that PHP is a very light language. Under normal temperature and pressure conditions, with a machine suitable for the amount of requests and with the proper optimizations in the code, everything tends to work well.

“But Matthew, what is a machine corresponding to the amount of requests?”
I have already participated in the implementation and optimization of complex applications that received more than 6 million requests per day Using, on average, two machines with 2 VCPUS and 2 GB of RAM each .

Now, talking about tools:

• php-fpm
  It is a FastCGI process manager for PHP, an alternative to the Apache PHP module. PHP-FPM is faster, flexible and widely used in production.

• OPCACHE
  A cache system for PHP scripts. It stores pre-compiled PHP code in memory, allowing PHP to perform faster, reducing execution time and resource consumption.

• Keep updated versions
  It is essential to keep packages, tools, frameworks and the most up -to -date PHP language as possible. I understand that often the effort to migrate from an older version, such as PHP 7.4, to a newer, like PHP 8.X, may seem loud. However, benefits in terms of performance, safety and support are worth the effort.

Important care:
Pay special attention to the configuration of threads and child processes (children processes). Setting very high values ​​for these settings or allowing the use of large files can overload the machine, leading to flaws and unavailability. Always adjust these settings according to machine capacity and real application requirements.

Monitoring

One of the most important items when we talk about optimizations is to understand what needs to be optimized. To do this, a good application monitoring tool (Application Performance Monitoring) can provide valuable information, and allow preventive actions before problems become critical.

There are several approaches to monitoring, from manual pHP log search to automated solutions. Among the automated tools, stand out:

new religion
datadatog

These tools are known as “plug and play”: just install the agent, restart the service and configure panels to create metrics and alerts.

On the other hand, there are more manual options that, while requiring greater effort and knowledge of the team, may be worth depending on the context:

• Prometheus Grafana
• Elastic Stack

The challenge in using these hand tools is the complexity they add, especially in robust applications without a dedicated support team. These solutions require a lot of configuration, strict tests and be careful to prevent agents from negatively impacting performance. In addition, they need layers and layers of FAILOVER - just a redundancy machine is often not enough.

Nevertheless, implementing and testing these tools can be a great challenge for a weekend!

In most cases, tools like New Relic offer a great starting point, providing great ability to prevent disasters. However, it is important to be aware of the cost, which can become significant depending on the use.

The above is the detailed content of Maximizing the application - PHP. For more information, please follow other related articles on the PHP Chinese website!