What is PostgreSQL?

PostgreSQL is an open-source relational database management system (RDBMS). It is known for its robustness, its ability to handle large volumes of data, and its compliance with SQL standards. The great thing about PostgreSQL is that it not only allows you to work with relational data, but also supports JSON queries, which gives you a lot of flexibility.
This system is widely used in all kinds of applications, from small mobile applications to large database management systems for high-traffic websites. Its active community and constant development make it a very attractive option for developers and system administrators.

Installing PostgreSQL on Ubuntu

Installing PostgreSQL on Ubuntu is a fairly straightforward process. Ubuntu has PostgreSQL in its default repositories, making installation as easy as running a few commands in the terminal.
To start, open a terminal on your Ubuntu system and follow these steps:

1. First, update your system’s package index with the command sudo apt update.
2. Then, install the PostgreSQL package using sudo apt install postgresql postgresql-contrib. This command will install PostgreSQL along with some additional modules that are useful.

Once the installation is complete, the PostgreSQL service will automatically start on your system. To verify that PostgreSQL is running, you can use the command sudo systemctl status postgresql.

Basic Management of PostgreSQL from the Console

Now that you have PostgreSQL installed, it’s time to learn some basic commands to manage your database from the console.

Accessing PostgreSQL

PostgreSQL creates a default user named postgres. To start using PostgreSQL, you will need to switch to this user. You can do this with the command sudo -i -u postgres. Once this is done, you can access the PostgreSQL console with the command psql.

Creating a Database and a User

Creating a database and a user is fundamental to getting started. To create a new database, use the command CREATE DATABASE your_database_name;.
To create a new user, use the command CREATE USER your_user WITH PASSWORD 'your_password';. It’s important to choose a secure password.

Assigning Privileges

After creating your database and user, you’ll want to assign the necessary privileges to the user. This is done with the command GRANT ALL PRIVILEGES ON DATABASE your_database_name TO your_user;.

Basic Operations

With your database and user set up, you can begin to perform basic operations. Some of the most common include:

• INSERT: To insert data into your tables.
• SELECT: To read data.
• UPDATE: To update existing data.
• DELETE: To delete data.

These commands form the basis of the SQL language and will allow you to interact with your data effectively.

Managing Security in PostgreSQL

Security is crucial when it comes to databases. PostgreSQL offers several features to secure your data. One of them is connection encryption, which you can set up to secure communication between your application and the database.
It’s also important to regularly review and update your passwords, and to carefully manage user permissions to ensure that they only have access to what they need.

Maintenance and Performance

Maintaining your PostgreSQL database in good condition is vital to ensuring optimal performance. PostgreSQL comes with some tools that will help you in this task, like the VACUUM command, which helps clean up the database and recover space.
Additionally, it’s advisable to perform regular backups. You can use the pg_dump command to backup your database.

Tips and Best Practices

To conclude, here are some tips and best practices that will help you get the most out of PostgreSQL:

• Stay up-to-date with PostgreSQL updates to take advantage of improvements and security fixes.
• Learn about indexes and how they can improve the performance of your queries.
• Familiarize yourself with PostgreSQL’s monitoring tools to keep an eye on the performance and health of your database.

I hope this article has provided you with a good foundation on PostgreSQL. Although we have not reached a formal conclusion, I hope this content is the start of your journey in the world of databases with PostgreSQL. Good luck!

La entrada Introduction to PostgreSQL se publicó primero en Aprende IT.

What is MongoDB?

MongoDB is an open-source, document-oriented NoSQL database system that has gained popularity due to its ability to handle large volumes of data efficiently. Instead of tables, as in relational databases, MongoDB uses collections and documents. A document is a set of key-value pairs, which in the world of MongoDB is represented in a format called BSON (a binary version of JSON). This structure makes it very flexible and easy to scale, making it particularly suitable for modern web applications and handling data in JSON format, which is common in the development of web and mobile applications.

The Difference Between SQL and NoSQL

To better understand MongoDB, it is crucial to differentiate between SQL and NoSQL databases. SQL databases (such as MySQL, PostgreSQL, or Microsoft SQL Server) use a structured query language (SQL) and are based on a predefined data schema. This means that you must know in advance how your data will be structured and adhere to that structure, which offers a high degree of consistency and ACID transactions (Atomicity, Consistency, Isolation, and Durability).
On the other hand, NoSQL databases like MongoDB are schematically dynamic, allowing you to save documents without having to define their structure beforehand. They are ideal for unstructured or semi-structured data and offer horizontal scalability, which means you can easily add more servers to handle more load.

Installing MongoDB on Ubuntu

Getting MongoDB up and running on your Ubuntu system is a fairly straightforward process, but it requires following some steps carefully. Here’s how to do it:

System Update

Before installing any new package, it is always good practice to update the list of packages and the software versions of your operating system with the following commands:

sudo apt update
sudo apt upgrade

Installing the MongoDB Package

Ubuntu has MongoDB in its default repositories, but to ensure you get the latest version, it is advisable to use the official MongoDB repository. Here’s how to set it up and carry out the installation:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv E52529D4
echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
sudo apt update
sudo apt install -y mongodb-org

Getting MongoDB Up and Running

Once installed, you can start the MongoDB server with the following command:

sudo systemctl start mongod

If you also want MongoDB to start automatically with the system, execute:

sudo systemctl enable mongod

Installation Verification

To verify that MongoDB is installed and running correctly, use:

sudo systemctl status mongod

Or you can try to connect to the MongoDB server using its shell:

mongo

Basic MongoDB Management from the Console

Now that you have MongoDB running on your Ubuntu machine, it’s time to learn some basic commands to manage your MongoDB instance from the console.

Creating and Using a Database

To create a new database, simply use the use command followed by the name of your database:

use myDatabase

If the database does not exist, MongoDB will create it when you save your first document.

Inserting Data

To insert data into a collection, you can use the insert command. For example:

db.myCollection.insert({ name: "Alice", age: 25 })

This will add a new document to the collection myCollection.

Reading Data

You can read or search for documents in a collection with the find command. For example:

db.myCollection.find({ name: "Alice" })

This will search for all documents where the name is “Alice”.

Updating Data

To update documents, you would use update. For example:

db.myCollection.update({ name: "Alice" }, { $set: { age: 26 } })

This will update Alice’s age to 26.

Deleting Data

And to delete documents, you simply use remove:

db.myCollection.remove({ name: "Alice" })

This will remove all documents where the name is “Alice”.

The Power of MongoDB Clusters

While managing a single instance of MongoDB may be sufficient for many projects, especially during development and testing phases, when it comes to production applications with large volumes of data or high availability requirements, setting up a MongoDB cluster can be essential. A cluster can distribute data across multiple servers, which not only provides redundancy and high availability but also improves the performance of read and write operations.
MongoDB clusters use the concept of sharding to distribute data horizontally and replicas to ensure that data is always available, even if part of the system fails. In another article, we will explore how to set up your own MongoDB cluster, but for now, it’s enough to know that this is a powerful feature that MongoDB offers to scale your application as it grows.

As you delve into the world of MongoDB, you’ll find that there is much more to learn and explore. From its integration with different programming languages to the complexities of indexing and query performance, MongoDB offers a world of possibilities that can suit almost any modern application need.

Remember that mastering MongoDB takes time and practice, but starting with the basics will put you on the right track. Experiment with commands, try different configurations, and don’t be afraid to break things in a test environment; it’s the best way to learn. The flexibility and power of MongoDB await, and with the foundation you’ve built today, you are more than ready to start exploring. Let’s get to work!

La entrada How to Get Started with MongoDB: Your Ultimate Guide se publicó primero en Aprende IT.

Understanding Ciphers and KexAlgorithms

To address these issues, you first need to understand some key concepts: ciphers and KexAlgorithms. These elements are fundamental for the security of your SSH connection and are used to encrypt and protect communication between your SSH client and the remote server.

What are Ciphers?

Ciphers, or encryption algorithms, are used to protect information transmitted through an SSH connection. These algorithms determine how information is encrypted and decrypted, ensuring that communication is secure and private.

What are KexAlgorithms?

On the other hand, KexAlgorithms, or key exchange algorithms, are essential for establishing a secure SSH connection. These algorithms are used to negotiate and agree upon the encryption key that will be used during the SSH session. They are a critical part of authentication and security in SSH.

The Importance of Firmware Updates

Before diving into details on how to fix encryption negotiation issues, it’s important to highlight the relevance of keeping your SSH server’s firmware updated. Manufacturers and software developers often release updates that fix security vulnerabilities and improve compatibility with the latest security standards. Keeping your firmware updated is a crucial measure to ensure the security of your SSH server.

Secure Protocols and Their Differences

Now that we understand ciphers and KexAlgorithms, it’s time to talk about the most secure protocols available for SSH. Two of the most commonly used protocols are SSHv1 and SSHv2, and it is essential to understand their differences.

SSHv1

SSHv1 is an older version of the SSH protocol and is considered obsolete due to known security vulnerabilities. It is not recommended for use in modern environments due to these weaknesses.

SSHv2

SSHv2 is the latest and most secure version of the SSH protocol. It offers better security and performance compared to SSHv1. Using SSHv2 over SSHv1 is highly recommended to ensure a secure SSH connection.

Fixing Encryption Negotiation Issues

Now that we have a solid understanding of the key concepts, let’s look at how to fix encryption negotiation issues in SSH.
When you encounter an error message like “no matching cipher found,” it means that the remote SSH server and your SSH client cannot agree on a cipher for secure communication. To resolve this issue, you can follow these steps:

Update Your SSH Client: Ensure that you are using an updated version of your SSH client. The latest versions typically support more secure ciphers and KexAlgorithms.

Specify Ciphers and KexAlgorithms: You can use specific options on the command line when connecting, as in the following example:

ssh -oKexAlgorithms=+diffie-hellman-group14-sha1 -oHostKeyAlgorithms=+ssh-dss -c aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc [IP address]

This tells your SSH client which ciphers and KexAlgorithms to use in the negotiation.

Contact the Server Administrator: If you are the administrator of the SSH server, ensure that it is configured to support secure ciphers and KexAlgorithms. Consider updating the configuration to use more secure protocols like SSHv2.
Remember that security is a top priority in SSH connections, and it is crucial to take measures to ensure that your communication is secure and private.

Conclusion

In this article, we have explored the concepts of ciphers and KexAlgorithms in SSH and their importance for the security of connections. We have also discussed the SSHv1 and SSHv2 protocols, highlighting the preference for SSHv2 due to its higher security.
Additionally, we have provided tips on how to fix encryption negotiation issues in SSH, including updating your SSH client, specifying the appropriate ciphers and KexAlgorithms, and considering server configuration.

Always remember to keep your software and firmware up to date to ensure the security of your SSH connections and effectively protect your data.

La entrada How to Fix Access Issues Due to Encryption Negotiation Errors in SSH se publicó primero en Aprende IT.

What is TFTP and what is it used for?

TFTP is an application layer protocol based on the client-server model. Unlike other file transfer protocols such as FTP or SCP, TFTP is much simpler and does not include features such as user authentication or encryption. This makes it ideal for situations where simplicity and speed are crucial, such as firmware updates on network devices.

One of the most common uses of TFTP is precisely in the field of networks, for uploading and downloading operating system images and configuration files on routers, switches, and other devices. When a network device needs to be updated or recovered, TFTP is often the chosen tool due to its simplicity and efficiency.

Choosing and Installing the Appropriate Software

There are several implementations of the TFTP server, but one of the most popular on Debian-based systems like Ubuntu is tftpd-hpa. This implementation stands out for its simplicity and its ability to get the job done without unnecessary complications.

To install tftpd-hpa on Ubuntu 22.04, open a terminal and run the following commands:

sudo apt update sudo apt install tftpd-hpa

This process will install the TFTP server and all the necessary packages on your system, leaving it ready to be configured.

Configuring tftpd-hpa

Once we have the TFTP server installed, the next step is to configure it to suit our needs. The main configuration file of tftpd-hpa is located in /etc/default/tftpd-hpa.

When opening this file with a text editor such as nano:

sudo nano /etc/default/tftpd-hpa

You will find several configuration lines. This is where we specify the details of our TFTP server’s operation. An example configuration might be:

TFTP_USERNAME="tftp" TFTP_DIRECTORY="/var/lib/tftpboot" TFTP_ADDRESS=":69" TFTP_OPTIONS="--secure"

Understanding the Configuration Options

• TFTP_USERNAME: Defines under which user the TFTP service will run. By default, this is usually tftp.
• TFTP_DIRECTORY: Sets the root directory of the TFTP server. All files that you want to be accessible via TFTP must be in this directory.
• TFTP_ADDRESS: Specifies the address and port on which the TFTP server will listen. :69 means that the server will accept connections on all network interfaces on TFTP’s standard port, 69.
• TFTP_OPTIONS: Here we can add additional options. With –secure, we ensure that only files within the specified directory can be accessed, an important security measure to avoid unwanted access.

It is crucial to ensure that the directory specified in TFTP_DIRECTORY exists and has the proper permissions. We can create it and assign permissions with the following commands:

sudo mkdir /var/lib/tftpboot sudo chown tftp:tftp /var/lib/tftpboot sudo chmod 777 /var/lib/tftpboot

Starting Up the Server

After having configured everything to our liking, it is time to restart the service to apply the changes:

sudo systemctl restart tftpd-hpa

And to make sure everything is working as it should, we can check the status of the service:

sudo systemctl status tftpd-hpa

If everything has gone well, you should see a message indicating that the service is active and running.

Securing Access: Configuring the Firewall

If you are using a firewall on your system, it is necessary to configure it to allow TFTP traffic. In the case of ufw, one of the most used firewalls in Ubuntu, the command would be:

sudo ufw allow 69/udp

This will open port 69 on the UDP protocol, which is used by TFTP.

Testing the Server

With everything in place, now is the time to test our TFTP server. We can do this from another machine using a TFTP client. On Ubuntu, we can install tftp-hpa, an implementation of the TFTP client:

sudo apt install tftp-hpa

With the client installed, we connect to the TFTP server:

tftp SERVER_ADDRESS

And once inside, we can use commands like get to download files or put to upload them.

Adjustments and Customizations

TFTP is a simple protocol, but that does not mean it cannot be adjusted and customized to meet our needs. From choosing the directory for the files to configuring the firewall, there are several ways to ensure that our TFTP server is running as best as possible.

The key is to understand the specific needs of your network and devices, and adjust the configuration accordingly. TFTP is a powerful tool in its simplicity, and with the right configuration, it can be an invaluable ally in network and system administration.

So whether you are an experienced system administrator or someone taking their first steps in the world of networks, setting up a TFTP server from scratch is a useful skill worth learning. With tftpd-hpa and Ubuntu 22.04, you have everything you need to get started. Go ahead and discover the power of TFTP for yourself!

La entrada Starting with a TFTP Server: A Guide from Scratch se publicó primero en Aprende IT.

Understanding Keepalived and VRRP

Keepalived is a software solution that relies on the VRRP (Virtual Router Redundancy Protocol) to create high availability systems. It provides a mechanism for servers to back each other up, so that if one fails, another can automatically take its place, ensuring service continuity.

Installing Keepalived on Ubuntu 22.04

Before starting the configuration of the virtual IP addresses, it is necessary to install Keepalived on your Ubuntu 22.04 system. You can do this by following these simple steps:
Update your system: Before installing any packages, make sure your system is updated:

sudo apt update && sudo apt upgrade -y

Install Keepalived:

Now, install Keepalived using the APT package manager:

sudo apt install keepalived -y

Basic Configuration

The first thing you have to do is navigate to the main configuration file:

sudo nano /etc/keepalived/keepalived.conf

Once inside, start configuring the VRRP instance. Imagine you want to establish high availability between two servers, A and B. Server A will be the primary and B the backup.

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 50
    priority 100
    advert_int 1
    virtual_ipaddress {
        192.168.1.100
    }
}

Here, server A is configured to be the MASTER and the virtual IP that both servers will share is 192.168.1.100.

Adjust Configuration for Server B

On server B, the configuration would be almost identical, with the only difference being that the state would be BACKUP and the priority would be a lower number, say 50.
This ensures that server A is always the primary, unless it fails. In that case, server B will take control.

Configuring Multiple VIPs on a Single Interface

Once Keepalived is installed, it’s time to move on to configuration. The ability to handle multiple VIPs is one of the most powerful features of Keepalived.
If you want to have several virtual IP addresses assigned to a single network interface, you can do so by adding multiple entries under virtual_ipaddress in your keepalived.conf configuration file.

Edit the Configuration File:

sudo nano /etc/keepalived/keepalived.conf

Add Your Configuration:

Here is an example of how to configure multiple VIPs on a single interface:

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    virtual_ipaddress {
        192.168.1.100
        192.168.1.101
        192.168.1.102
    }
}

In this example, three virtual IP addresses have been configured on the eth0 interface.

Configuring a VIP per Interface

If you prefer to have a virtual IP address assigned to different interfaces, you will need to create multiple VRRP instances.
Edit the configuration file:

sudo nano /etc/keepalived/keepalived.conf

Add Your Configuration:

Here is an example of how to configure a VIP per interface:

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 52
    priority 100
    advert_int 1
    virtual_ipaddress {
        192.168.1.100
    }
}
vrrp_instance VI_2 {
    state MASTER
    interface eth1
    virtual_router_id 53
    priority 100
    advert_int 1
    virtual_ipaddress {
        192.168.2.100
    }
}

In this example, a VIP has been assigned to the eth0 interface and another VIP to the eth1 interface.

Restart Keepalived to Apply Changes

After making changes to the configuration file, it is necessary to restart the Keepalived service to apply the changes:

sudo systemctl restart keepalived

And to ensure it starts with the system:

sudo systemctl enable keepalived

Verification and Monitoring

Now that everything is set up, it is important to verify that everything is working as expected and to maintain constant monitoring.

Check the Service Status:

sudo systemctl status keepalived

Check the Logs

The logs will provide you with valuable information about the behavior of Keepalived:

sudo journalctl -u keepalived

Benefits of Using Keepalived for Multiple VIPs

By using Keepalived to manage multiple VIPs, you get a robust and flexible system that can adapt to the needs of your infrastructure. This not only ensures the availability of your services but also provides a balanced load distribution, which is vital for maintaining optimal performance.

Final Words

High availability is a critical component in today’s IT infrastructure, and tools like Keepalived offer an effective and efficient solution. With its ability to handle multiple VIPs, whether on a single interface or distributed across several interfaces, Keepalived positions itself as an indispensable tool for system administrators and developers looking to ensure the continuity of their digital services.
Therefore, invest time in configuring and understanding Keepalived; your infrastructure will thank you, and your users will enjoy an uninterrupted and reliable service. Go ahead, secure your environment with Keepalived today!

La entrada How to Have High Availability Services with Keepalived se publicó primero en Aprende IT.

Why have your own S3?

You might wonder if it’s really worth it, with so many offers already available on the market. But think about the autonomy, the costs you save, and the adaptability according to your needs. Or just think about the challenge and the technical fun that comes with it.

Meet MinIO, the star of our story

MinIO is more than just software. It’s an object storage solution known for its performance and, to top it off, it’s open-source. Moreover, it works wonderfully with Amazon S3’s API, so if you’re already familiar with S3, with MinIO you’ll feel right at home.

Setting up MinIO on Ubuntu 22.04

The beginning: Installation

Let’s start from the beginning, okay? Assuming you already have your machine with Ubuntu 22.04 ready:

Download MinIO:

Open your terminal and type:

wget https://dl.min.io/server/minio/release/linux-amd64/minio

Give it permissions:

We want it to be executable:

chmod +x minio

Starting up: First run

Once installed, it’s time to get it running.

Run MinIO:

Suppose you’ve decided to save your data in /data; first, we execute:

mkdir /data

Then, we can launch the software in the following way, but it’s not best practice as one can access with the default user minioadmin and password minioadmin:

./minio server /data

To avoid the above, you can run it defining a user and password with the environment variables set for it:
That is:

MINIO_ROOT_USER=YourUsername MINIO_ROOT_PASSWORD=YourPassword ./minio server /data

For example:

root@MinIO:~# MINIO_ROOT_USER=LearnIT MINIO_ROOT_PASSWORD=102371209673jhdef ./minio server /data 
MinIO Object Storage Server
Copyright: 2015-2023 MinIO, Inc.
License: GNU AGPLv3 <https://www.gnu.org/licenses/agpl-3.0.html>
Version: RELEASE.2023-10-16T04-13-43Z (go1.21.3 linux/amd64)

Status: 1 Online, 0 Offline. 
S3-API: http://146.255.69.234:9000 http://127.0.0.1:9000 
RootUser: LearnIT 
RootPass: 102371209673jhdef

Console: http://146.255.69.234:46267 http://127.0.0.1:46267 
RootUser: LearnIT 
RootPass: 102371209673jhdef

Command-line: https://min.io/docs/minio/linux/reference/minio-mc.html#quickstart
$ mc alias set 'myminio' 'http://146.255.69.234:9000' 'LearnIT' '102371209673jhdef'

Documentation: https://min.io/docs/minio/linux/index.html
Warning: The standard parity is set to 0. This can lead to data loss.

This way of starting it is safer, but the software runs in the foreground; you can send it to the background in the following ways:

• Use software like screen and run it.
• You can use nohup.
• Another option is to configure a service with systemd.

Access and explore:

Now you can go to your browser and type the IP address of the server where you installed MinIO and port 9000; for example, if you installed it locally, you can type http://localhost:9000. With the credentials you’ve set up, you can start exploring the world of MinIO.

High Availability with MinIO

Having a server is good, but if we want it to be reliable, we need to think in terms of high availability.

MinIO in distributed mode, the art of expansion

If you have multiple servers, MinIO has got you covered! You can have them work together in a distributed cluster. Imagine four servers working together, creating a robust distributed storage system.

Erasure Coding, or how MinIO protects your data

Thanks to this technique, MinIO splits your data into fragments distributed across all servers. If one fails, there’s no problem; the data can be reconstructed from the fragments on the other servers.

Load balancer? Yes, please

With multiple servers accepting requests, it’s advisable to use a load balancer, such as NGINX or HAProxy. This ensures traffic is properly distributed and handles potential issues from any of the nodes.

Alternatives to MinIO

Of course, the world of object storage is vast, and MinIO is not alone. Let’s look at some alternatives:

Ceph with its S3 Gateway

Advantages:

• Highly scalable.
• Can manage not just object storage but also block storage and filesystems.

Disadvantages:

• More complex to configure than MinIO.
• Requires more hardware resources to get started.

OpenStack Swift

Advantages:

• Integrated into the OpenStack ecosystem.
• Specifically designed for scalability and redundancy.

Disadvantages:

• Its learning curve can be steeper if you’re not familiar with OpenStack.
• Initial configuration is more complex than MinIO.

La entrada How to Set Up Your Own S3 Server se publicó primero en Aprende IT.

Python is a powerful and versatile programming language, popular for its readability and simplicity. But it’s also a high-level language with automatic memory management, which means the programmer doesn’t have to worry too much about memory allocation and release.

That doesn’t mean we can forget about memory management entirely. In fact, a solid understanding of how Python handles memory under the hood can help you write more efficient code and avoid unexpected issues. So let’s dive into this fascinating topic.

Memory and the Garbage Collector

Before we get into specific tips and tricks, let’s understand a bit more about how Python manages memory.

When you create an object in Python, the system reserves a block of memory to store it. This memory block stays occupied as long as the object exists, that is, as long as there is some reference to it in your code.

However, when an object is no longer needed (there are no references to it), that memory block isn’t freed up right away. Python has a component called the “garbage collector” that is in charge of freeing up the memory taken up by objects that are no longer needed.

The Importance of References

Understanding how references work in Python can be very handy for managing memory efficiently. When you assign a variable to an object, you’re actually creating a reference to the object, not a copy of the object.

This is important because it means that if you assign a variable to another object, the previous reference is lost and the original object can be garbage collected, freeing its memory. But be careful: if there are other references to the original object, it won’t get deleted.

Immutable and Mutable Variables

Another aspect you need to keep in mind when managing memory in Python is the difference between immutable and mutable variables. Numbers, strings, and tuples are immutable, which means that once they’re created, their value can’t change.

On the other hand, lists, dictionaries, and most user-defined objects are mutable, which means their value can change. When you modify a mutable object, the change happens in the same memory block.

Tricks to Optimize Memory Management

Now that we understand the basics, let’s look at some tricks that can help you manage memory more efficiently in Python.

Using Generators

Generators are a powerful feature of Python that allows you to iterate over a sequence of values without having to generate the entire sequence in memory at once. Instead, the values are generated on the fly, one at a time, which can save a significant amount of memory if the sequence is large.

Avoid Unnecessary References

Remember that every reference to an object keeps the object in memory. Therefore, if you want an object to be garbage collected, make sure to remove all references to it when you no longer need it.

Using __slots__ in Classes

If you’re defining a class that’s going to have many instances, you can save memory by using __slots__. This is a Python feature that limits the attributes that an instance of a class can have, which can reduce the amount of memory used to store each instance.

Object Recycling

In some cases, it might be useful to recycle objects instead of creating new ones. For example, if you have a list of objects that are used intermittently, you can keep them in a “pool” and reuse them as needed, instead of creating new objects each time.

Getting to Know Python’s Diagnostic Tools

Last but not least, it’s helpful to know the tools Python provides for memory diagnostics. The Python standard library includes modules like gc and tracemalloc that you can use to monitor and control memory management.

The gc module allows you to interact with the garbage collector, while tracemalloc provides detailed information about the memory being used by your program.

So there you have it. Memory management in Python might seem like a complicated topic, but with these tips and tricks, you can start writing more efficient and optimized code. Remember, every little detail counts when it comes to optimizing the efficiency of your code and these tips are a great place to start.

Do you have any other tips or tricks you’d like to share? We’d love to hear about it in the comments!

La entrada Memory Management in Python: Handy Tips and Tricks to Optimize Your Code se publicó primero en Aprende IT.

La entrada Comparison: Kibana vs. Grafana for Monitoring se publicó primero en Aprende IT.

Why is it necessary to increase the LUN ID limit?

In storage systems, logical units (LUNs) are unique addresses assigned to each storage device on a storage area network (SAN). These addresses allow servers to access storage devices efficiently. However, FC (Fibre Channel) and SCSI (Small Computer System Interface) cards have default LUN limits that may be insufficient for large or growing storage environments. Increasing the maximum number of LUNs on these cards allows for greater scalability and flexibility, especially in cases where managing a large number of storage devices is required.

Kernel Modules: scsi_mod and lpfc

Before diving into the process of increasing the maximum number of LUNs, it’s essential to understand the kernel modules involved. Kernel modules are pieces of code that can be dynamically loaded and unloaded in the operating system kernel, allowing you to modify its functionality without needing to reboot.

scsi_mod

The scsi_mod module is the main module of the SCSI subsystem in the Linux kernel. It provides basic SCSI functionality, including device detection, command management, and communication with SCSI device drivers.

lpfc

The lpfc module is a Fibre Channel device driver for Emulex cards, enabling communication between the operating system and FC cards. This module is responsible for the configuration and operation of Emulex cards in the system.

Increasing the LUN ID Limit in Kernel Modules

Modifying the grub

Open the grub configuration file with a text editor:

sudo nano /etc/default/grub

Look for the line that starts with GRUB_CMDLINE_LINUX and add the following parameters at the end of the list of options:

scsi_mod.max_luns=65535 lpfc.max_lun=65535

The modified line should look like this:

GRUB_CMDLINE_LINUX="quiet splash scsi_mod.max_luns=65535 lpfc.max_lun=65535"

Save the changes and close the file.

Update the grub configuration for the changes to take effect:

sudo update-grub

Reboot the system to apply the new values:

sudo reboot

Using modprobe.d files

Create a new configuration file in the /etc/modprobe.d directory:

sudo nano /etc/modprobe.d/scsi-lun.conf

Add the following lines to the file to set the maximum LUN limits for scsi_mod and lpfc:

options scsi_mod max_luns=65535
options lpfc lpfc_max_lun=65535

Save the changes and close the file.

Reload the kernel modules to apply the changes:

sudo depmod -a
sudo modprobe -r scsi_mod lpfc
sudo modprobe scsi_mod lpfc

Using echo

To temporarily modify the LUN ID limit until the next reboot, you can use the echo command to write the new value to the corresponding parameter files:

echo 65535 | sudo tee /sys/module/scsi_mod/parameters/max_luns
echo 65535 | sudo tee /sys/module/lpfc/parameters/lpfc_max_lun

Checking the Current Limits with CAT

To verify the current LUN ID limits in scsi_mod and lpfc, use the CAT command:

cat /sys/module/scsi_mod/parameters/max_luns
cat /sys/module/lpfc/parameters/lpfc_max_lun

These commands will display the current values of the LUN limits for each module.

Additional Considerations

By default, the qla2xxx module has a LUN ID limit of 65535, so there’s no need to modify it. The scsi_mod and lpfc modules have a default limit of 255 LUNs. By increasing the limit to 65535, you achieve greater flexibility and scalability in large storage environments.

Remember, it’s essential to perform thorough testing after making changes to your system’s configuration. A poor adjustment can negatively affect performance and stability. Moreover, it’s always a good idea to back up configuration files before modifying them so you can restore them if you run into any issues.

We hope this article has been helpful in learning how to overcome the LUN ID limit in storage systems, and how to increase the maximum number of LUNs in FC and SCSI cards. Now, you’ll be able to manage a larger number of storage devices on your network and take full advantage of the scalability and flexibility these systems offer.

La entrada Overcoming the LUN ID Limit in Storage Systems: How to Increase the Maximum Number of LUNs in FC and SCSI Cards se publicó primero en Aprende IT.

La entrada The 5 Pillars of Successful DevOps Culture se publicó primero en Aprende IT.