netstat has long been a useful tool for displaying network-related information on Linux systems. However, it has been deprecated in favor of newer tools like ss and ip, which provide similar network monitoring and management capabilities. These tools are considered more modern and offer better performance. Here are two of the primary tools that replace netstat on Linux:

1. ss (Socket Statistics):ss is a replacement for netstat and is part of the iproute2 package. It is used to display detailed information about network sockets, interfaces, routing tables, and more. ss provides a more efficient and flexible way to monitor and troubleshoot network connections. Some common ss commands include:
   • Display all listening and non-listening sockets:ss -a
   • List all TCP sockets:ss -t
   • Show UDP sockets:ss -u
   • Display established connections:ss -t -a state established
   • Show listening ports:ss -t -l
2. ip (iproute2): The ip command is a versatile utility for configuring and managing network interfaces, routes, and more. While it’s not a direct replacement for netstat, it provides more comprehensive control over network configurations. Some ip commands include:
   • Show information about all network interfaces:ip a
   • Display routing table information:bashCopy codeip route
   • Show statistics for a specific interface (e.g., eth0):ip -s link show dev eth0
   • Add or modify network routes:ip route add default via 192.168.1.1

Both ss and ip offer improved performance and more detailed information than netstat. They are commonly available on modern Linux distributions. However, note that they may require superuser (root) privileges or the use of sudo to access some information. You can refer to their respective man pages (man ss and man ip) for detailed usage and command options.

While these tools have largely replaced netstat for modern Linux systems, it’s worth mentioning that some Linux distributions might still include netstat for compatibility reasons. However, using ss and ip is recommended for more up-to-date and accurate network-related information and configurations.

On a Linux system that uses systemd for managing services and logs, you can use the journalctl command to display system logs. Systemd’s journal provides a centralized and efficient way to access and analyze log data. Here are some common journalctl commands for viewing system logs:

1. View the entire journal: To display the entire system log, use the journalctl command without any options:journalctl This will display log entries starting with the most recent.
2. View logs since a specific time: You can view logs since a specific time by using the -S (since) option:journalctl -S "YYYY-MM-DD HH:MM:SS" Replace “YYYY-MM-DD HH:MM:SS” with the desired timestamp.
3. View logs for a specific unit (service): To view logs for a specific systemd unit (e.g., a service), use the -u option followed by the unit name:journalctl -u your-service-name
4. View logs with a specified priority (log level): You can filter logs by priority (log level) using the -p option. For example, to view only messages with priority “error” or higher:bashCopy codejournalctl -p err You can use different log levels, such as “emerg,” “alert,” “crit,” “err,” “warning,” “notice,” “info,” and “debug.”
5. Display logs as a continuous stream: To view logs in real-time as they are written to the journal, use the -f option:journalctl -f Press Ctrl+C to exit the continuous view.
6. Display logs from the previous boot: To view logs from the previous boot, you can use the -b option with an offset. For example, to view logs from the last boot:journalctl -b -1 The -1 indicates the previous boot, and you can use -2 for the boot before that, and so on.
7. Filter logs by a specific process or program: To filter logs by a specific process or program, you can use the -t (tag) option. For example:journalctl -t your-process-name
8. View logs in a pager (e.g., less): By default, journalctl may display logs using a pager (usually “less”) for easier navigation. You can scroll through logs using arrow keys, and press q to exit.

These are some of the common journalctl commands to display Linux system logs using systemd. The journal provides a powerful and flexible way to access and search for log information on a systemd-managed system.

Debugging Bash scripts involves identifying and resolving errors, unexpected behavior, or issues in your script. Here are some techniques and tools you can use to debug Bash scripts effectively:

1. Use set -x: You can add set -x at the beginning of your script to enable debugging mode. This will display each command and its result as it is executed. For example:#!/bin/bash set -x echo "Hello, World" When you run the script, it will display each line with a “+ ” prefix to show the command and its output.
2. Use set -e: Adding set -e makes your script exit immediately if any command returns a non-zero exit status. This can help you catch errors early in your script. For example:#!/bin/bash set -e echo "Hello, World" # This will exit the script if the previous command fails
3. Use echo and read: You can insert echo statements at various points in your script to print variables, intermediate results, or messages. This can help you track the progress of your script and identify where issues may be occurring. You can also use read to pause script execution to inspect variables or the state of your script.
4. Check variable values: Make sure to echo or print the values of variables to the terminal to verify that they contain the expected data. For example:#!/bin/bash my_variable="Hello, World" echo "my_variable contains: $my_variable"
5. Use set -u: Enabling set -u will make your script exit if it references an uninitialized variable. This can help catch issues where you expect a variable to be set but it isn’t.
6. Redirect output to a log file: You can redirect the output of your script to a log file using the > or >> operators. This can be useful for reviewing the script’s output later and identifying any errors. For example:#!/bin/bash ./my_script.sh > debug.log 2>&1
7. Comment out sections: Temporarily comment out sections of your script to isolate the problematic code. By narrowing down the issue to a specific part of your script, you can focus your debugging efforts more effectively.
8. Use a text editor or IDE with syntax highlighting: Writing your script in a text editor or integrated development environment (IDE) with Bash syntax highlighting can help you spot syntax errors more easily.
9. Run your script step by step: If your script is long and complex, consider running it step by step. You can execute individual sections of code to verify their correctness. To do this, you can copy and paste the commands into your terminal or use the source command to execute a script file within the current shell.
10. Check for error messages: Pay attention to any error messages or warnings generated by the script. They can provide valuable information about what went wrong.

By using these techniques and a systematic approach, you can effectively debug Bash scripts and identify and resolve issues more efficiently.

Verify Service Name:

# systemctl list-units | grep post

Verify Service Status:

# systemctl status postgresql

Verify Port used by the Service:

# netstat -pnlt

Example: