DEV Community: elad gasner

Simplicity in Optimization: Enhance Your System with Swap

elad gasner — Tue, 26 Sep 2023 12:00:29 +0000

Swap space, often referred to simply as "swap," is a dedicated area on a computer's storage device, typically a hard drive or SSD, used as virtual memory. It's an integral component of operating systems like Linux and Windows and plays a crucial role in efficiently managing a computer's memory (RAM). When the physical RAM reaches its capacity, swap space comes into play as an extension of your system's memory, ensuring that your system continues to function without interruption.

Adding Swap Space for Improved Performance:

If you find yourself with limited physical RAM and want to enhance your system's performance by providing additional virtual memory, adding swap space can be a beneficial solution. Here's how you can augment your system's capabilities with 2GB of RAM:

Note: Before proceeding, make sure you have administrative privileges on your system.

Check Current Swap: Before adding more swap space, it's a good idea to check if you already have existing swap space. Open a terminal and run:

swapon --show

This will display any active swap partitions/files.

Create a Swap File: If you don't have existing swap space, you can create a swap file. Choose a location with enough disk space. To create a 2GB swap file, run the following commands:

sudo fallocate -l 2G /swapfile   # Create a 2GB swap file
sudo chmod 600 /swapfile         # Set appropriate permissions
sudo mkswap /swapfile            # Format the file for swapping

Activate the Swap File: Once the swap file is created, you need to activate it:

sudo swapon /swapfile   # Activate the swap file

Make Swap Permanent: The swap file will be deactivated after a reboot unless you add it to your system's configuration. Edit the /etc/fstab file to make the swap permanent:

sudo nano /etc/fstab

Add the following line at the end of the file:

/swapfile none swap sw 0 0

Save and exit the text editor.

Adjust Swappiness (Optional): Swappiness controls how aggressively your system uses swap space. A value of 0 avoids swap as much as possible, while a value of 100 aggressively uses swap. To adjust swappiness, run:

sudo sysctl vm.swappiness=10

This sets swappiness to a lower value (e.g., 10) to avoid swapping too much. To make the change persistent after reboot, add the following line to the /etc/sysctl.conf file:

 vm.swappiness=10

Check Swap: After performing these steps, you can check if the swap space is active:

swapon --show
free -h

The free -h command will display your system's memory usage, including swap.

Adding swap space can improve your system's performance, but it's important to note that swap is slower than physical RAM. It's better to have enough RAM for your needs, but swap can be a helpful supplement when RAM is limited.

The Art of Resource Optimization: Lessons from Restaurant Operations for Server Efficiency

elad gasner — Wed, 05 Jul 2023 20:54:38 +0000

Imagine you want to open a new and charming restaurant in the heart of the city. With unique menu ideas, a strongbackground in culinary arts, and a thriving restaurant market, you're excited to introduce your new creation to the
world. But despite the excitement, there are important considerations you need to take into account.

On the one hand, you want to provide the best and fastest service possible. Customers who feel that your service is slow
and inefficient will choose to go to a competing restaurant.

Therefore, your initial thought will be to have as many waiters and chefs as possible. Maybe even one waiter and one
chef per table. This way, you can ensure the fastest service.

On the other hand, you have limited resources. Waiters and chefs require salaries, money, and if you want to make a
profit, you need to minimize labor costs.

So perhaps just one chef and one waiter? This will negatively impact your service when there is a high volume of
customers. One waiter and one chef will struggle to handle the load, and the service will be very slow.

Another option is to time the waiters based on demand. Call the waiter only when customers arrive. However, this is also
not a good solution because it takes time for the waiter to arrive and start providing service, which will negatively
affect customer service.

The solution is to manage wisely. Define a small number of waiters who are consistently present from the opening of the
restaurant. Set a maximum number of waiters available during peak demand.
When there is no waiter available, there is no reason for them to leave immediately when there is no demand. Therefore,
define a time for how long the waiter will stay after finishing their service.

The server is like the restaurant, providing the main service. In each server, you have a limited number of resources,
such as RAM. Just as in a restaurant, you have various roles like waiters and chefs, in a server, you have a number of
processes running in the background, such as in a LEMP server:

NGINX
PHP-FPM
MYSQL

In that guide, we will focus on PHP-FPM. However, we can apply this to other services as well.

First, let's start by understanding your resource usage.
You can do this using the command:

 free -h

The free command displays information about memory (RAM) usage on your computer in a readable and understandable
format.

The information displayed by the command includes:

Total: The total amount of memory on your computer.
Used: The amount of memory currently in use by processes and programs on your computer.
Free: The amount of memory not in use and available for immediate use by additional processes or programs.
Available: The amount of memory available for additional use. This includes memory not in use at the moment and can be immediately used by additional processes or programs.
Buffers/Cache: The amount of memory used by the system for temporary data storage or caching of information. This data helps improve system performance.

Now, let's determine the memory "cost" of each waiter, or in this case, each PHP-FPM process.

You can use the ps command to find and sort active PHP-FPM processes by their Resident Set Size (RSS), which is the
amount of physical memory (RAM) used by the process.

We will run the following command:

ps -ylC php-fpm --sort:rss

The command displays a list of php-fpm processes and sorts them based on their physical memory size from smallest to
largest.

"ps": The command itself to display a list of processes.
"-y": Displays the processes in a "table" format with additional columns.
"-l": Shows detailed information about the processes, including the parent process of each process.
"-C php-fpm": Displays processes only for the process named "php-fpm".
"--sort:rss": Sorts the processes based on their physical memory size (RSS, Resident Set Size) from smallest to largest.

To calculate the average, we will use the 'awk' command and run the following:

ps --no-headers -o "rss,cmd" -C php-fpm7.0 | awk '{ sum+=$1 } END { printf ("%d%s\n", sum/NR/1024,"M") }'

Now that we have information about our resources and the average cost of each process,
we can determine the number of processes we want to run.

The settings can be found in the file /etc/php/X.0/fpm/pool.d/www.conf, depending on the PHP version.

pm.max_children = 17
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3

max_children

First, we define the maximum number of servers we can handle by calculating a portion of the average resources required
by each process.

For example: 2560 Mb / 60 Mb = 42 max_children

start_servers

Once we know the maximum number, we don't want to use them all the time as it would overload the server.
Therefore, we set a minimum number of servers when the restaurant opens by editing the value of start_servers.

min_spare_servers & max_spare_servers

After customers start arriving and the servers get busy,
we want to set a minimum number of available servers so that customers don't have to wait for a server to be called and
organized.
We achieve this by editing the parameter value of min_spare_servers.

In other words, if we set start_servers to 5 and min_spare_servers to 3, when the server load increases, 5
processes will automatically be running.
Once 3 of them start providing service, the process manager (pm) will start an additional server to ensure availability.

If the load becomes excessive and many servers are already running, we don't want to send them home quickly.
Instead, they will stay in the restaurant. However, since there is currently no load,
we define a maximum limit for the number of spares using the max_spare_servers field.

To summarize, in the restaurant world, as well as in the server world,
proper allocation of resources and processes is the key to smooth and efficient operation. With precise settings and
smart use of technological tools, we can ensure that your restaurant (host server) positively impacts customers (users)
and meets their needs professionally and efficiently.

Why you should build your own framework but you shouldn’t use it

elad gasner — Sun, 14 May 2023 20:24:55 +0000

Building your own web framework can be a rewarding experience for any developer. Not only do you gain a deeper understanding of how web development works, but you also have the potential to create a tool that can be used in your own projects.

However, the question remains: should you use the framework you just built in your production projects? While it might be tempting to do so, I believe there are compelling reasons why you shouldn't.

I want to share with you my experience of building my own framework, the challenges I faced, and why I ultimately decided not to use it for my production projects. By the end of this article, you'll have a better understanding of why building your own framework is a valuable learning experience, but why you should stick to using established frameworks for your production work.

When I started learning Laravel, I decided to create my own framework from scratch. I wanted to understand how Laravel worked under the hood, and I thought it would be a good way to learn. I spent countless hours researching and coding, and eventually, I had my own custom framework up and running.

At first, I was excited to start using my new framework for all my projects. But as I began to use it more and more, I realized that it had a lot of flaws. There were bugs I hadn't noticed, features that didn't work as intended, and performance issues that slowed down my applications.

I tried to fix these issues, but it quickly became apparent that maintaining my own framework was a full-time job. I was spending more time fixing my framework than actually building applications. And every time I fixed one issue, another one seemed to pop up.

That's when I realized that building your own framework is a great way to learn, but it's not necessarily the best way to build software. Frameworks like Laravel and Symfony are widely used and well-tested, and they have a large community of developers contributing to their development. By using one of these established frameworks, you can focus on building your application rather than maintaining your framework.

Building your own web framework can be a fun and challenging project, but when it comes to production work, stability is key. Your clients rely on you to deliver a stable and reliable system that meets their needs. By using established frameworks like Laravel or Symfony, you can leverage the years of development and testing that have gone into these projects to create a more stable system.

Of course, that's not to say that building your own framework is a waste of time. On the contrary, building your own framework can be an incredibly rewarding experience that teaches you a lot about web development. Just don't expect to use it for production applications. Instead, use it as a learning tool to gain a deeper understanding of how frameworks work.

In conclusion, building your own framework can be a valuable learning experience, but it's not the best way to build software. Instead, use an established framework like Laravel or Symfony for your production applications. By doing so, you can focus on building great applications without getting bogged down by framework maintenance.