DEV Community: Ruslan Kh.

SWAP: Guide about swap and swappiness

Ruslan Kh. — Mon, 23 Sep 2024 11:41:25 +0000

If you're tired of seeing the same old instructions on setting up SWAP in Linux, especially the ones that insist on using dd, you're not alone. This isn't just another tutorial on enabling SWAP; it's a practical guide that goes beyond the basics, addressing better and more efficient ways to manage your system's memory. We'll explore why fallocate might be a smarter choice and dive into optimizing swappiness for better performance.

What is SWAP?

SWAP is a designated area on your disk that serves as overflow space for your system's RAM. When your system runs out of physical memory (RAM), it moves inactive data from RAM to the SWAP space, freeing up memory for other tasks. This process is known as "swapping."

Why is SWAP important?

Increased Virtual Memory: SWAP allows the system to use more memory than is physically available in RAM.
System Stability: Without SWAP, running out of RAM could lead to system crashes, as the system wouldn't be able to handle new memory allocation requests.
Memory Management Flexibility: SWAP is useful in systems with limited RAM or under heavy load, where temporary expansion of available memory is needed.

Types of SWAP:

SWAP Partition: A dedicated partition on the disk used exclusively for SWAP.
SWAP File: A file within the filesystem that can be used as SWAP space.

Setting Up SWAP:

1. Creating a SWAP Partition:

Use fdisk or parted to create a new partition on your disk, and set the partition type to "Linux swap" (code 82).
Apply the changes to update the partition table.
Format the partition as SWAP using the command:

mkswap /dev/sdXn

Activate the SWAP partition:

swapon /dev/sdXn

To make the SWAP permanent after reboot, add an entry to /etc/fstab:

/dev/sdXn swap swap defaults 0 0

2. Creating a SWAP File:

Instead of using dd, you can use fallocate, which is faster and simpler for creating SWAP files.

Create a SWAP file of the desired size (e.g., 2 GB):

fallocate -l 2G /swapfile

Set the correct permissions for the file:

chmod 600 /swapfile

Initialize the file as SWAP:

mkswap /swapfile

Enable the SWAP file:

swapon /swapfile

To ensure the SWAP file is mounted automatically after a reboot, add an entry to /etc/fstab:

/swapfile swap swap defaults 0 0

Why Use `fallocate` Instead of `dd`?

Speed: fallocate allocates space instantly without writing zeros across the file, unlike dd.
Simplicity: The command is straightforward and does not require specifying block size or count.

When to Prefer dd?

Compatibility: fallocate may not be supported on all filesystems, particularly older or non-standard ones, where dd might be necessary.
Physical Block Reservation: If you need to create a file with physically reserved blocks, dd is useful because it fills the file with data, ensuring that disk space is reserved.
Performance Testing: dd can create files with specific content patterns, useful for performance testing or when a file needs to be filled with a specific data template.

Checking SWAP Status:

To check the current SWAP status, use:

swapon --show

free -h

Adding Multiple SWAP Files:**

If your system needs more SWAP space, you don't need to expand an existing SWAP file. Instead, you can add additional SWAP files. Each new SWAP file can be created and activated separately, and the system will manage them automatically. This approach is flexible and allows you to scale your SWAP space as needed without modifying existing files.

Creating Additional SWAP Files:

Create a new SWAP file (e.g., 1 GB):

fallocate -l 10G /swapfile_2

Set the appropriate permissions:

chmod 600 /swapfile_2

Initialize it as SWAP:

mkswap /swapfile_2

Enable the new SWAP file:

swapon /swapfile_2

Managing SWAP Priorities:

Each SWAP file can have a different priority, which determines the order in which the system uses them. The priority is set when you activate the SWAP file using the swapon command:

swapon /swapfile_2 -p 10

In this example, /swapfile_2 has a higher priority than other SWAP files with the default priority (0). The system will use the higher-priority SWAP space first.

Example with multiple swap files:

~$ swapon -s 
Filename       Type    Size        Used         Priority
/swapfile_1    file    67108860    51176372     -2
/swapfile_2    file    67108860    12404496     -3
/swapfile_3    file    134217724   186348       -4
/swapfile_4    file    134217724   0            -5

Tuning SWAP Parameters: Understanding `swappiness`

Swappiness is a kernel parameter that controls how aggressively your Linux system will move data from RAM to SWAP. It is expressed as a value between 0 and 100.

Low Swappiness (e.g., 10): Tells the system to avoid swapping unless absolutely necessary, keeping most of the data in RAM. This is useful when you have a large amount of RAM and you want to minimize disk I/O, because accessing data in RAM is much faster than accessing it on disk.
High Swappiness (e.g., 60 or higher): Makes the system more eager to use SWAP space, even when RAM is still available. This can be useful in environments where you want to keep more free RAM for caching or if the SWAP space is on a fast SSD, making the performance hit less noticeable.

The default value of swappiness is usually set to 60, which provides a balanced approach. However, depending on your specific use case and system resources, you might want to adjust it.

To temporarily change the swappiness value:

sysctl vm.swappiness=10

To make the change permanent across reboots, add the following to /etc/sysctl.conf:

vm.swappiness=10

Why Adjust Swappiness?

Adjusting swappiness allows you to fine-tune how your system manages its memory, optimizing for performance, reducing disk wear on systems with SSDs, or ensuring better utilization of available RAM. By lowering the swappiness value, you can prioritize keeping active data in RAM, which is useful for workloads that are sensitive to latency. Conversely, increasing swappiness might be beneficial in systems with constrained memory, where offloading to SWAP earlier can help maintain system responsiveness.

The Evolution and Impact of MLOps: understanding MLOps

Ruslan Kh. — Sat, 27 May 2023 14:00:58 +0000

Machine Learning Operations, or MLOps, is the missing bridge between machine learning, data science, and data engineering. It has emerged as the link that unifies these functions more seamlessly than ever before. So what is MLOps, and why does it matter? In this article, we'll dive into the MLOps Hierarchy of Needs, a fundamental concept that illustrates how MLOps supports, enhances, and optimizes the machine learning workflow within an organization.

DevOps: The Foundation of MLOps

To understand MLOps, we must first understand the structure of this hierarchy, which can be visualized as a pyramid. At the base of this pyramid is DevOps, the practice that enables continuous delivery and automated provisioning of environments. Without a solid DevOps foundation, there's no way an organization can successfully implement MLOps. Key components of DevOps include infrastructure as code and a robust build system that allows services to be deployed in the staging environment and automatically propagated to production.

DevOps, a combination of "development" and "operations," is a collaborative approach that streamlines the software development process. It bridges the gap between development and operations teams, facilitating continuous integration and delivery. This methodology is essential for an organization to dive into MLOps.

Key components of DevOps include Infrastructure as Code (IaC), continuous delivery, and a design based on a robust build system. IaC enables automated provisioning of environments that can be integrated with your build system, providing significant flexibility and reproducibility. Similarly, continuous delivery ensures that microservices are systematically updated in the staging environment and propagated to production, increasing speed and efficiency.

Data Operations: The Next Level

Once the foundational level of DevOps is established, the next step is to focus on data operations. This involves setting up data management platforms such as Google BigQuery, Databricks, Snowflake, or Amazon Athena. These platforms facilitate serverless query and visualization workflows, making data processing easier. They also support data jobs and tasks to ensure efficient data operations.

MLOps Platforms: Essential tools for machine learning

The third layer is the implementation of an MLOps platform. This layer emphasizes the use of specialized tools rather than building everything from scratch, which can take a lot of time away from core business objectives. Building on the data operations layer, it's time to integrate MLOps platforms. These are specialized tools designed to streamline the machine learning process, including feature stores, model serving platforms, and experiment tracking tools. Feature stores store pre-curated features for reuse, while model serving platforms manage the deployment of ML models. Experiment tracking tools help track various metrics and explanatory techniques, and also monitor data drift, allowing you to measure the impact of a model in production and observe how the underlying data changes over time. They help monitor different metrics, training techniques, and data drift - a concept that describes how the performance of an ML model can degrade over time as the underlying data changes.

The MLOps layer: Workflow Automation

Finally, we reach the top of the pyramid - the MLOps layer itself. Here, the focus is on business value. It's important to ensure that the machine learning models being created are delivering value to the organization. This value can be tracked and quantified, providing visibility that is useful for the health, security, and reputation of the organizations using the models. Getting the problem right is also critical at this stage - solving the wrong problem can lead to wasted resources and missed opportunities.

MLOps is not just about process, it is also about transforming people and technology. Successful MLOps implementation requires the participation of people from different levels and departments in an organization, creating a culture of best practices.

There are several trends and predictions for MLOps in 2023. One key trend is the continued investment in machine learning, driven by the rapid evolution of MLOps and the machine learning industry. However, the integration of MLOps continues to present challenges. The onboarding and deployment of AI and ML algorithms can be complex, requiring careful workload orchestration and server balancing.

A growing number of organizations are adopting tools like Metaflow, open-sourced by Netflix and AWS, to design, run, and deploy their workflows at scale, automatically versioning and tracking all experiments and data. There is no consensus on a single MLOps tool or application, and the growing number of libraries and packages in MLOps is expected to have a significant impact on enterprises.

Conclusion

The MLOps Hierarchy of Needs is a structured approach to implementing MLOps in an organization. By starting with DevOps and gradually building up to data operations, MLOps platforms, and finally the MLOps layer itself, organizations can streamline their ML workflows and maximize their business value. The goal of MLOps isn't just about automation; it's about driving efficiency and accelerating business outcomes.

Implementing MLOps can enable capabilities such as accurate inventory forecasting and the discovery of new patterns through unsupervised machine learning. But remember, the journey to MLOps is not a sprint; it's a marathon. It requires consistent effort, constant learning, and the right resources to successfully implement and manage MLOps in an organization.

React 18 server components deep dive

Ruslan Kh. — Sun, 21 May 2023 19:50:21 +0000

React Server Components (RSC) is a promising feature that can have a significant impact on page load performance, bundle size, and the way we write React applications. This feature is still experimental in React 18, but it's worth understanding how it works under the hood.

Separation of server and client components

React Server Components allows the server and client (browser) to work together to render your React application. Some components in the React element tree are rendered by the server, and some are rendered by the browser. This is not the same as server-side rendering (SSR). SSR simulates an environment for rendering a React tree into raw HTML, but it does not distinguish between server and client components.

The React team has defined server and client components based on the extension of the file in which the component is written: if the file ends in .server.jsx, it contains server components; if it ends in .client.jsx, it contains client components. If it ends in neither, it contains components that can be used as both server and client components.

Life of an RSC Render

The life of a page using RSC always begins on the server, in response to an API call to render a React component. The server then serializes the root component element into JSON. The end goal here is to render the initial root server component into a tree of basic HTML tags and client component placeholders.

The server then sends this serialized tree to the browser, and the browser can do the work of deserializing it, filling the client placeholders with the actual client components, and rendering the end result.

RSC and Suspense

Suspense plays an important role in RSC. Suspense allows you to throw promises from your React components when they need something that is not yet ready (fetching data, lazily importing components, etc). These promises are captured at the suspense boundary. When a promise is thrown from rendering a Suspense subtree, React stops rendering that subtree until the promise is resolved, and then tries again.

RSC Wire Format

The server outputs a simple format with a JSON blob on each line, tagged with an ID. This format is very streamable - once the client has read a full line, it can parse a snippet of JSON and make some progress.

Consuming the RSC Format

The react-server-dom-webpack package contains the entrypoints that take the RSC response and rebuild the React element tree. When the server finishes loading the data, it outputs the rows for the module reference - which defines the module reference to the component - and the React element tree that should be swapped into where the reference is.

RSC vs. Fetching Data from Client Components

Whether RSC is better than fetching data from client components depends on what you are rendering to the screen. With RSC, you get denormalized, "processed" data that maps directly to what you are showing to the user. If the rendering requires multiple data fetches that depend on each other in a waterfall, then it is better to do the fetching on the server - where data latency is much lower - than from the browser.

RSC and SSR

With React 18, it is possible to combine both SSR and RSC, so you can generate HTML on the server and then hydrate that HTML with RSC in the browser.

Server-Side Rendering (SSR)

Server-side rendering (SSR) is a technique where a React application is rendered on the server into a static HTML string, which is then sent to the client. This can improve performance and SEO by allowing the page to be displayed before all the JavaScript has been loaded and parsed.



import express from 'express';
import React from 'react';
import ReactDOMServer from 'react-dom/server';
import App from './App';

const server = express();

server.get('/', (req, res) => {
  const appString = ReactDOMServer.renderToString(<App />);

  res.send(`
    <!DOCTYPE html>
    <html>
      <head>
        <title>My App</title>
      </head>
      <body>
        <div id="root">${appString}</div>
        <script src="/bundle.js"></script>
      </body>
    </html>
  `);
});

server.listen(8080);

In this example, the App component is rendered to a string on the server, and that string is inserted into the HTML response. The client then "hydrates" this static HTML into a fully interactive React application.

React Server Components (RSC)

React Server Components (RSC) allow the server and client to work together to render a React application. Some components render on the server, and others render on the client. This can improve performance by reducing the amount of JavaScript sent to the client and allowing the server to fetch and render data directly.

Here's a simple example of RSC:



// Message.server.js

import {db} from './db.server';

function Message({id}) {
  const message = db.messages.get(id);
  return (
    <div>
      <h1>{message.title}</h1>
      <p>{message.body}</p>
    </div>
  );
}

export default Message;



// App.client.js

import {useState} from 'react';
import Message from './Message.server';

function App() {
  const [selectedId, setSelectedId] = useState(1);
  return (
    <div>
      <button onClick={() => setSelectedId(selectedId + 1)}>
        Next
      </button>
      <Message id={selectedId} />
    </div>
  );
}

export default App;

In this example, the Message server component retrieves and renders a message based on an id prop. The App client component maintains a piece of state (selectedId) and renders the Message server component with the current id.

Practical Recommendations

Understand the difference between server and client components: Understanding which components are rendered by the server and which are rendered by the client is critical to using RSC effectively.
Use Suspense with RSC: Suspense allows you to handle promises in your React components, which is integral to the functioning of RSC
Optimize for performance: RSC can significantly improve page load performance and reduce bundle size. However, it's important to measure and monitor these metrics to ensure that you're getting the expected benefits.
Consider the tradeoffs: While RSC offers many benefits, it also comes with tradeoffs. For example, server components cannot use states or effects, which can limit their use in certain scenarios.
Experiment with RSC in non-critical parts of your application: Given the experimental nature of RSC, it may be a good idea to start experimenting with it in non-critical parts of your application. This will give you a better understanding of how it works and how it can be used effectively.
Combine RSC with other React features: RSC can be combined with other React features like Suspense and Concurrent Mode to build more efficient and user-friendly applications.

Examples.

Let's look at some code examples to illustrate how React Server Components (RSC) work.

First, let's define a server component. Server components are identified by the .server.js extension:



// Message.server.js

import {db} from './db.server';

function Message({id}) {
  const message = db.messages.get(id);
  return (
    <div>
      <h1>{message.title}</h1>
      <p>{message.body}</p>
    </div>
  );
}

export default Message;

In this example, Message is a server component that fetches a message from a database based on an id prop. Notice that we're directly importing a server module (db.server) and using it to fetch data. You can't do this in a client component.

Next, let's define a client component that uses this server component:



// App.client.js

import {useState} from 'react';
import Message from './Message.server';

function App() {
  const [selectedId, setSelectedId] = useState(1);
  return (
    <div>
      <button onClick={() => setSelectedId(selectedId + 1)}>
        Next
      </button>
      <Message id={selectedId} />
    </div>
  );
}

export default App;

In this example, App is a client component that maintains a piece of state (selectedId) and renders the Message server component with the current id. When the Next button is clicked, the selectedId is incremented, causing the Message component to be rendered again with the new id.

This is a simple example, but it illustrates the key idea behind RSC: server components can be used to fetch and render data on the server, while client components maintain interactivity on the client.

Comparison

While both SSR and RSC involve rendering on the server, they serve different purposes and have different tradeoffs:

SSR is primarily concerned with improving performance and SEO by sending static HTML to the client. However, it requires sending all JavaScript to the client, which can be large and slow to parse.
RSC, on the other hand, allows the server and client to collaborate on rendering, which can reduce the amount of JavaScript sent to the client and improve performance. However, server components cannot use states or effects, which can limit their use in certain scenarios.
In summary, both SSR and RSC are powerful techniques for rendering React applications, each with its own strengths and tradeoffs. Understanding these differences can help you make more informed decisions about which technique to use in your projects.

Links:
https://react.dev/blog/2022/03/29/react-v18
https://react.dev/blog/2020/12/21/data-fetching-with-react-server-components
https://react.dev/blog/2023/03/22/react-labs-what-we-have-been-working-on-march-2023#react-server-components
https://shopify.github.io/hydrogen-v1/tutorials/react-server-components
https://www.plasmic.app/blog/how-react-server-components-work

Enhancing Directory Navigation with pushd

Ruslan Kh. — Fri, 14 Apr 2023 10:51:59 +0000

Getting Started

Efficient directory navigation is crucial when working with the command line. In Bash, you can use the pushd command to simplify and improve your directory navigation. pushd allows you to store directories on a stack so that you can switch between them quickly and efficiently. In this article, we will explore the use of pushd and how it can improve your command-line workflow.

Using pushd

The pushd command is used to change the current working directory while pushing the previous directory onto a stack called the directory stack. This stack is managed by three commands: pushd, popd, and dirs.

pushd: Adds a directory to the stack and changes the current working directory.
popd: Removes the top directory from the stack and changes the current working directory to the new top directory.
dirs: Displays the contents of the directory stack.

Basic pushd usage

To start using pushd, simply run the command followed by the directory you want to navigate to:

$ pushd /path/to/directory

This command adds the specified directory to the stack and changes the current working directory. The previous working directory is also stored on the stack.

Navigating between directories

You can use pushd to navigate between directories by specifying the directory to switch to. The current directory is pushed to the stack, and the specified directory becomes the new current working directory:

$ pushd /another/path/to/directory

Going Back to the Previous Directory

To revert to the previous directory, use the pushd command without arguments:

$ pushd

This command swaps the top two directories on the stack and changes the current working directory to the new top directory.

Viewing the Directory Stack

To view the contents of the directory stack, use the dirs command:

$ dirs

This command displays the directories stored on the stack, with the top directory on the left and the bottom directory on the right.

Removing directories from the stack

To remove the top directory from the stack and navigate to the new top directory, use the popd command:

$ popd

This command removes the current directory from the stack and changes the current working directory to the new top directory.

Workflow example

Here's an example of how pushd, popd, and dirs are used in a typical workflow:

$ pushd /path/to/directory1
$ pushd /path/to/directory2
$ dirs # Display the directory stack
$ pushd # Switch back to the previous directory (/path/to/directory1)
$ popd # Remove the current directory from the stack and switch to the next one (/path/to/directory2)
$ dirs # Display the directory stack
$ popd # Remove the current directory from the stack and switch to the next one (original directory)

Example 1 : Navigating to different project directories

#!/bin/bash

# Navigate to the first project directory
pushd /path/to/project1

# Run commands specific to project1
echo "Running tasks for project1..."
# Your commands for project1 here

# Navigate to the second project directory
pushd /path/to/project2

# Run commands specific to project2
echo "Running tasks for project2..."
# Your commands for project2 here

# Return to the first project directory
popd

# Run cleanup tasks for project1
echo "Cleaning up project1..."
# Your cleanup commands for project1 here

# Return to the original directory
popd

Example 2: Temporarily navigating to a subdirectory

#!/bin/bash

# Navigate to a subdirectory
pushd ./subdir

# Run commands in the subdirectory
echo "Running tasks in subdir..."
# Your commands for subdir here

# Return to the original directory
popd

# Continue executing the script in the original directory
echo "Running tasks in the original directory..."
# Your commands for the original directory here

Example 3: Looping through multiple directories

#!/bin/bash

# An array of directories to process
directories=(
  "/path/to/directory1"
  "/path/to/directory2"
  "/path/to/directory3"
)

for dir in "${directories[@]}"; do
  # Navigate to the directory
  pushd "$dir"

  # Run commands specific to the current directory
  echo "Processing directory: $dir"
  # Your commands for the current directory here

  # Return to the original directory
  popd
done

Conclusion

By using the pushd, popd, and dirs commands, you can greatly improve your command line directory navigation experience. These commands allow you to store directories on a stack and quickly switch between them, making it easier to manage multiple directories and improving your workflow.

ESXiArgs encryption malware launches massive attacks against VMware ESXi servers

Ruslan Kh. — Mon, 06 Feb 2023 13:07:26 +0000

Hosting providers and CERT-FR warn: A new ransomware named ESXiArgs has compromised more than 3,200 VMware ESXi servers in a recent massive hacking campaign. The attackers are exploiting a two-year-old vulnerability (CVE-2021-21974) in OpenSLP (port 427) that allows them to execute remote commands on the vulnerable servers. The vulnerability is related to a dynamic memory overflow in OpenSLP that can be exploited by unauthenticated attackers. This vulnerability affects ESXi version 7.x, ESXi version 6.7.x, and ESXi version 6.5.x.

Once inside the victim's system, the ransomware encrypts the files on the ESXi server and leaves a ransom note demanding $50,000 in bitcoins to decrypt the data. The encrypted files have extensions like .vmxf, .vmx, .vmdk, .vmsd, and .nvram. An analysis by experts at OVHcloud suggests that the Nevada encryption engine was responsible for the attacks.

CERT-FR experts recommend installing patches that have been available for a while and checking all vulnerable systems for signs of compromise. As a last resort, they recommend disabling OpenSLP.

An analysis of the malware by IS expert Michael Gillespie shows that the encryptor has no weaknesses that would allow victims to recover files without paying the ransom. The malware uses the Sosemanuk encryption algorithm. Although the malware operators claim to steal data before encrypting it, victims refute this information and their traffic statistics show no signs of data theft.

It is worth noting that an exploit for this problem has been available since spring 2021 and appeared shortly after the bug was disclosed. It is not at all clear why attackers would wait until now to exploit this bug.

CERT-FR experts strongly recommend everyone to install the patches that have long been available as soon as possible and to check all vulnerable systems for signs of compromise. As a last resort, the experts recommend at least disabling OpenSLP.

An analysis by experts at cloud service provider OVHcloud blamed the recent Nevada encryption engine for the massive attacks. The experts wrote that "attacks primarily target ESXi servers up to version 7.0 U3i via the OpenSLP port (427)".

At the same time, other experts speculated that a version of the Cheerscrypt ransomware, based on leaked sources of the Babuk crypto-ransomware, could be behind the attacks.

Bleeping Computer reports that victims are actively communicating and asking for help on its forums. According to the data collected, most of the affected organizations were using ESXi servers leased from cloud providers.

The ransomware encrypts files with .vmxf, .vmx, .vmdk, .vmsd, and .nvram extensions on compromised servers, and creates an .args file with metadata for each encrypted document (presumably needed for decryption).

for volume in $(IFS='\n' esxcli storage filesystem list | grep "/vmfs/volumes/" | awk -F'  ''{print $2}'); do
    echo "START VOLUME: $volume"
    IFS=$'\n'
    for file_e in $( find "/vmfs/volumes/$volume/" -type f \
        -name "*.vmdk" -o \
        -name "*.Vmx" -o \
        -name "*.vmxf" -o \
        -name "*.vmsd" -o \
        -name "*.vmsn" -o \
        -name "*‚vswp" -o \
        -name "* vmss" -o \
        -name "* .nvram" -o \
        -name "* . vmem")
    do
        if [[ -f "$file_e" ]]; then 
            size_kb=$(du -k $file_e | awk '{print $1}')
            if [[ $size_kb -eq 0 ]]; then
                size_kb=1
            fi
            size_step=0
            if [[ $(($size_kb/1024)) -gt 128 ]]; then
                size_step=$((($size_kb/1024/100)-1))
            fi 
            echo "START ENCRYPT: $file_e SIZE: $size_kb STEP SIZE: $size_step" "\"$file_e\" $size_step 1 $((size_kb*1024))"
            echo $size_step 1 $((size_kb*1024)) > "$file_e.args"
            nohup $CLEAN_DIR/encrypt $CLEAN_DIR/public.pem "$file_e" $size_step 1 $((size_kb*1024)) > /dev/null 2>&1&
        fi
    done
    IFS-$" "
done

Although malware operators claim to steal data before encrypting it, victims refute this information: Victim's traffic statistics show no signs of data theft.

French cloud provider OVH and the French CERT were the first to report the incident, as most of the affected servers are located in France. According to Censys (ransom note file search), more than 3,200 servers have been encrypted so far, and about a third of them are located in France.

Configure Touch ID for sudo access in Terminal.app without prompting for a password to authenticate.

Ruslan Kh. — Sun, 05 Feb 2023 18:24:59 +0000

Devices listed below have fingerprint scanner (Touch ID) to simplify login process but this is not exposed in Terminal.app. So each time you run commands with elevated privileges you need to type in your password.

Compatibility list:

MacBook Air (13-inch, M3, 2024)
MacBook Air (15-inch, M3, 2024)
MacBook Air (15-inch, M2, 2023)
MacBook Air (13-inch, M2, 2022)
MacBook Air (M1, 2020)
MacBook Pro (13‑inch, M2, 2022)
MacBook Pro (13-inch, M1, 2020)
MacBook Pro (14‑inch, 2023)
MacBook Pro (14‑inch, 2021)
MacBook Pro (16‑inch, 2023)
MacBook Pro (16-inch, 2021)
iMac (24-inch, M3, 2023)
iMac (24-inch, M1, 2021)
Mac Studio (2023)
Mac Studio (2022)
Mac mini (2023)
Mac mini (M1, 2020)
Mac Pro (2023)

Magic Keyboard's Touch ID functionality is compatible with the following MacBook/iMac models:

MacBook Air (M1, 2020)
MacBook Pro (13", M1, 2020)
MacBook Pro (14", 2021)
MacBook Pro (16", 2021)
iMac (24", M1, 2021)
Mac mini (M1, 2020)

Please note that the keyboard will still pair and function with devices older than those listed, but that Touch ID functionality will not be enabled.

Setup PAM module to use Touch ID:

To allow Touch ID on your Mac to authenticate you for sudo access instead of a password prompt you need to do the following simple changes.

Open Spotlight:

Type `terminal` in `Spotlight` input field and open it:

Open Terminal:

Switch to the root user.

Switch to the root user by typing the command sudo su - and enter the password:

sudo su -

Edit `/etc/pam.d/sudo`:

Open the /etc/pam.d/sudo file with you favorite editor such as vim or nano:

nano /etc/pam.d/sudo

The contents of this file should look like one of the following example:

Add the following line to the top of the file:

auth       sufficient     pam_tid.so

The modified contents of /etc/pam.d/sudo file should look like following example:

Save the file:

for nano, press the specified combination (with sign “+”) of keys simultaneously:

CTRL+o 
CTRL+x

for vim:

<ESC>
:wq

Allow the system to save the changes.

Press OK button:

Also note that pam_smartcard.so may not be present on older MacOS versions. Tested with macOS Ventura (13.1).

Exit from the shell.

Exit from the root shell by typing command: exit.

Try to use sudo, and you should be prompted to authenticate with Touch ID as shown below.

sudo echo "Check Touch ID"

If you click ‘Cancel,’ you can just enter your password at the terminal prompt. If you click ‘Use Password’ you can enter your password in the dialog box.

If you connect to your macOS via SSH, it will revert to using your password, since you cannot send Touch ID fingerprints over SSH.

Note: Recent MacOS updates may remove the entry. If Touch ID stops working for sudo then check if the entry was removed and add it back in, following these instructions again.

F.A.Q.

Does it work with Warp terminal?

Yes, additional settings are not required.

Does it work with iTerm2?

Yes, but additional settings may be required.

If you are using iTerm2 (v3.2.8+), you may have noticed that Touch ID does not work with sudo in the terminal, even though you have done the pam_tid.so modification above and it worked in earlier versions. This is due to an advanced feature that seems to be enabled by default now - it needs to be disabled here: iTerm2->Preferences > Advanced > Allow sessions to survive logouts and logins.

Identifying Disks in Dedicated Servers

Ruslan Kh. — Sun, 05 Feb 2023 17:58:40 +0000

Maintaining a server's health is crucial for ensuring smooth operation of a business or organization's IT infrastructure. One of the tasks involved in maintaining a server's health is replacing failed or failing disks. However, identifying which disk needs to be replaced can be a difficult and dangerous task if the correct procedures are not followed.

It is often necessary to identify disks for a number of reasons, including replacing a failed disk, searching for a specific disk, or upgrading to faster or larger disks.

If there is a large number of servers located in different data centers, it is not always possible to independently replace the disk in the server, in this case the replacement is performed by data center engineers, who should be prepared, which drive must be replaced, indicating the rack and the unit in which the server is located.

To reduce the risks, it is important to have a clear method of indicating which drive needs to be replaced. This can be done using platform tools such as disk LED indicators.

In this article, we will discuss the importance of highlighting the disk that needs to be replaced, the difficulties involved in identifying the disk in the server, and the dangers of disconnecting the wrong disk. We will also provide an overview of the different methods available for highlighting the disk that needs to be replaced, so that administrators can make informed decisions about which solution best suits their needs.

Why is disk identification important? In many cases, servers are configured with RAID arrays, which provide redundancy and improves perfomance. If a disk fails, it is essential to identify the correct disk to replace it in order to maintain the integrity of the system. When upgrading disks, it is also important to ensure that the correct disk is targeted to avoid any potential data loss.

Risks of incorrectly chosen disks. If the wrong disk is identified, there is a high risk of data loss and system damage, particularly in the case of RAID1 arrays. Before performing any disk-related operations, it is important to take precautions to prevent such risks.

In this article, we will cover two popular server systems: Huawei and Supermicro, and provide a guide on how to identify disks in both systems.

Before performing any disk-related operations, it is important to check the contents of the locate file and set the value to 0 to ensure that the disk you are manipulating is the one you need.

for i in $(find /sys -name 'locate'); do echo 0 > "$i"; done

Huawei.

Disk Identification on Huawei servers.

We will assume that the failed disk has the identification /dev/sdaj.

To identify a disk in a Huawei server, you can use the following steps:

Access the system shell
Locate the disk:

> ls /sys/class/enclosure/*/*/device/block/sdaj    <TAB>

Use the TAB key to autocomplete the device name, for example:

> ls /sys/class/enclosure/0\:0\:38\:0/ArrayDevice23/device/block/sdaj/

To find the location of the ArrayDevice, run the following command:

> find /sys -name "locate" | grep ArrayDevice23

/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/host0/port-0:0/expander-0:0/port-0:0:38/end_device-0:0:38/target0:0:38/0:0:38:0/enclosure/0:0:38:0/ArrayDevice23/locate

Turn on the UID LED:

> echo 1 > '/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/host0/port-0:0/expander-0:0/port-0:0:38/end_device-0:0:38/target0:0:38/0:0:38:0/enclosure/0:0:38:0/ArrayDevice23/locate'

Supermicro.

Disk Identification on Supermicro servers.

When using Supermicro, I came across two ways to identify disks. The only difference is the presence of a space in the slot name.

Method #1

We will assume that the failed disk has the identification /dev/sda.

Access the system shell
Locate the disk:

> ls /sys/class/enclosure/*/*/device/block/sda    <TAB>

Use the TAB key to autocomplete the device name, for example:

> ls /sys/class/enclosure/1\:0\:13\:0/Slot00/device/block/sda/

To find the location of the ArrayDevice, run the following command:

> find /sys -name "locate" | grep Slot00
/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/host1/port-1:1/expander-1:1/port-1:1:11/end_device-1:1:11/target1:0:25/1:0:25:0/enclosure/1:0:25:0/Slot00/locate
/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/host1/port-1:0/expander-1:0/port-1:0:13/end_device-1:0:13/target1:0:13/1:0:13:0/enclosure/1:0:13:0/Slot00/locate

Turn on the UID LED:

> echo 1 > '/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/host1/port-1:1/expander-1:1/port-1:1:11/end_device-1:1:11/target1:0:25/1:0:25:0/enclosure/1:0:25:0/Slot00/locate'

Method #2

We will assume that the failed disk has the identification /dev/sdh.

Access the system shell
Locate the disk:

> ls /sys/class/enclosure/*/*/device/block/sdh/

Use the TAB key to autocomplete the device name, for example:

> ls /sys/class/enclosure/0\:0\:25\:0/Slot\ 08/device/block/sdh/

To find the location of the ArrayDevice, run the following command:

> find /sys -name "locate" | grep Slot\ 08
/sys/devices/pci0000:00/0000:00:02.2/0000:03:00.0/host0/port-0:1/expander-0:1/port-0:1:0/end_device-0:1:0/target0:0:25/0:0:25:0/enclosure/0:0:25:0/Slot 08/locate
/sys/devices/pci0000:00/0000:00:02.2/0000:03:00.0/host0/port-0:0/expander-0:0/port-0:0:24/end_device-0:0:24/target0:0:24/0:0:24:0/enclosure/0:0:24:0/Slot 08/locate

Turn on the UID LED:

> echo 1 > '/sys/devices/pci0000:00/0000:00:02.2/0000:03:00.0/host0/port-0:0/expander-0:0/port-0:0:24/end_device-0:0:24/target0:0:24/0:0:24:0/enclosure/0:0:24:0/Slot 08/locate'

In some cases to identify a disk in server, you will need to use a specialized disk compatible with controller that has the ability to analyze errors and display an indicator, usually in red. The process may differ depending on the platform, so it is recommended to consult the user manual or vendor's documentation for specific instructions.

In exceptional cases where there is no UID LED indication, you can use less reliable methods. For example by loading the drive with reads, which will cause a continuous green LED indication.

In conclusion, disk identification is an important aspect of server management that must be performed with care to prevent data loss and system damage. By following the steps outlined in this guide, you can identify disks in Huawei and Supermicro servers with confidence. I hope my experience will help you to identify disks when it is not possible to enable disk UID indication using IPMI.

DEV Community: Ruslan Kh.

SWAP: Guide about swap and swappiness

What is SWAP?

Why is SWAP important?

Types of SWAP:

Setting Up SWAP:

2. Creating a SWAP File:

Why Use fallocate Instead of dd?

Adding Multiple SWAP Files:**

Managing SWAP Priorities:

Tuning SWAP Parameters: Understanding swappiness

Why Adjust Swappiness?

The Evolution and Impact of MLOps: understanding MLOps

DevOps: The Foundation of MLOps

Data Operations: The Next Level

MLOps Platforms: Essential tools for machine learning

The MLOps layer: Workflow Automation

Conclusion

React 18 server components deep dive

Separation of server and client components

Life of an RSC Render

RSC and Suspense

RSC Wire Format

Consuming the RSC Format

RSC vs. Fetching Data from Client Components

RSC and SSR

Server-Side Rendering (SSR)

React Server Components (RSC)

Practical Recommendations

Examples.

Comparison

Enhancing Directory Navigation with pushd

Getting Started

Using pushd

Basic pushd usage

Navigating between directories

Going Back to the Previous Directory

Viewing the Directory Stack

Removing directories from the stack

Workflow example

Conclusion

ESXiArgs encryption malware launches massive attacks against VMware ESXi servers

Configure Touch ID for sudo access in Terminal.app without prompting for a password to authenticate.

Compatibility list:

Setup PAM module to use Touch ID:

Open Spotlight:

Type terminal in Spotlight input field and open it:

Open Terminal:

Switch to the root user.

Edit /etc/pam.d/sudo:

Save the file:

Allow the system to save the changes.

Exit from the shell.

F.A.Q.

Does it work with Warp terminal?

Does it work with iTerm2?

Identifying Disks in Dedicated Servers

Huawei.

Supermicro.

Method #1

Method #2

Why Use `fallocate` Instead of `dd`?

Tuning SWAP Parameters: Understanding `swappiness`

Type `terminal` in `Spotlight` input field and open it:

Edit `/etc/pam.d/sudo`: