Kamran Ahmed
6 months ago
parent
3d53ce67e9
commit
7b297bdba6
105 changed files with 1719 additions and 160 deletions
@ -1 +1,16 @@ |
||||
# Basic commands |
||||
# Linux Navigation Basics: Basic Commands |
||||
|
||||
In the world of Linux, understanding how to navigate through the system is quite essential. Unlike many other modern operating systems, Linux primarily uses command-line interfaces (CLI) thereby, making it necessary to get comfortable with different commands. These basic commands under Linux navigation involve moving around the file system, viewing the contents of directories, creating, renaming or deleting files/directories, and more. Navigating through Linux using these commands not only increases efficiency, but also provides a deeper understanding of the system's file and directory structure. |
||||
|
||||
```bash |
||||
# Change directory |
||||
cd /path/to/directory |
||||
|
||||
# List contents of a directory |
||||
ls |
||||
|
||||
# View current working directory |
||||
pwd |
||||
``` |
||||
|
||||
In this brief introduction, we will discuss and explore these basic commands and how they aid us in navigation around the Linux environment. |
||||
@ -1 +1,13 @@ |
||||
# Moving files |
||||
# Moving Files |
||||
|
||||
In Linux, moving files is an essential task that you will need to perform quite frequently. The `mv` command, short for move, is used to move files and directories from one location to another. The `mv` command can also be used for renaming files in Linux. |
||||
|
||||
The general syntax for the `mv` command is as follows: |
||||
|
||||
```bash |
||||
mv [options] source destination |
||||
``` |
||||
|
||||
Here, `source` denotes the file or directory that you want to move while `destination` denotes the location where you want to move your source file or directory. |
||||
|
||||
The `mv` command is widely used because of its simplicity and versatility. Whether you want to organize your files by moving them into different directories or rename a bunch of files, the `mv` command is your go-to tool in Linux. |
||||
@ -1 +1,19 @@ |
||||
# Creating files |
||||
# Creating Files |
||||
|
||||
Linux provides a versatile and powerful command-line interface (CLI) that helps users perform various tasks including file creation and navigation. Learning how to create files is among the fundamental skills for novices venturing into the Linux world. One of the simplest ways to create a file in Linux is with the `touch` command. This command, when supplied with the name of a file as a parameter, either creates a new file with the given name or, if a file with such name is already present, updates the last modified time of the file. |
||||
|
||||
Another useful command for creating files is `cat >filename`. This command creates a new file with the specified name and waits for user input. Hence, the process ends when you press `Ctrl+D` to send `EOF` (End-Of-File) to the `cat` command. |
||||
|
||||
Here's an example of file creation with the `touch` command: |
||||
|
||||
```bash |
||||
touch newfile.txt |
||||
``` |
||||
|
||||
and with `cat` command: |
||||
|
||||
```bash |
||||
cat > newfile.txt |
||||
``` |
||||
|
||||
Both these commands create a new "newfile.txt" if it does not already exist. |
||||
@ -1 +1,7 @@ |
||||
# Directory hierarchy |
||||
# Understanding Directory Hierarchy |
||||
|
||||
In Linux, understanding the directory hierarchy is crucial for efficient navigation and file management. A Linux system's directory structure, also known as the Filesystem Hierarchy Standard (FHS), is a defined tree structure that helps to prevent files from being scattered all over the system and instead organise them in a logical and easy-to-navigate manner. |
||||
|
||||
Each directory serves a specific purpose. For instance, `/bin` holds binary executable files (command files), `/etc` has system configuration files, `/home` stores users' personal files, and `/var` contains varying files such as logs and print queues. |
||||
|
||||
No code snippet is necessary as understanding directory hierarchy is a conceptual knowledge and doesn't involve code execution. |
||||
@ -1 +1,29 @@ |
||||
# Navigation basics |
||||
# Navigation Basics |
||||
|
||||
In Linux, navigation between directories and files is a fundamental, yet essential function that allows you to exploit the power of the command-line interface (CLI). Mastering the basic Linux navigation commands such as `cd`, `pwd`, `ls`, and `tree` enables you to flawlessly move from one point to another within the filesystem, display the list of files & directories, and understand your position relative to other system components. These commands are advantageous not just to system administrators but to anyone interacting with Linux environments, hence familiarizing yourself with them is a critical step in building Linux proficiency. |
||||
|
||||
Here is how you use these commands: |
||||
|
||||
- To change directories, use the `cd` command: |
||||
|
||||
```bash |
||||
cd /path/to/directory |
||||
``` |
||||
|
||||
- To print the current directory, use the `pwd` command: |
||||
|
||||
```bash |
||||
pwd |
||||
``` |
||||
|
||||
- To list the contents of a directory, use the `ls` command: |
||||
|
||||
```bash |
||||
ls |
||||
``` |
||||
|
||||
- The `tree` command displays directories as trees (system hierarchy): |
||||
|
||||
```bash |
||||
tree |
||||
``` |
||||
@ -1 +1,14 @@ |
||||
# Vim |
||||
# Vim: An Essential Tool for Editing Files |
||||
|
||||
Vim, an acronym for 'Vi Improved', is a highly configurable and complex text editor built to enable efficient text editing in Linux environments. It is an improved version of the 'vi' editor, a standard text editor that comes with a UNIX operating system. While learning Vim can have a steep learning curve, its powerful features allow users to accomplish tasks more quickly than with many other text editors. |
||||
|
||||
One of the key reasons that make Vim popular among developers is its ability to handle large files adeptly, having a less memory footprint. Moreover, it operates in different modes such as 'command mode', 'insert mode', and 'visual mode' which eases the process of editing files. |
||||
|
||||
Although the challenge of learning Vim may seem daunting, it is a fundamental tool for anyone seeking mastery in the Linux environment. |
||||
|
||||
A simple use of Vim to edit a 'example.txt' file would look like this: |
||||
```bash |
||||
vim example.txt |
||||
``` |
||||
|
||||
To insert new content, press 'i' for 'insert mode'. After editing, press 'ESC' to go back to 'command mode', and type ':wq' to save and quit. |
||||
@ -1 +1,13 @@ |
||||
# Nano |
||||
# Nano: A File Editing Tool |
||||
|
||||
Nano is a popular, user-friendly text editor used for creating and editing files directly within the Linux command line interface (CLI). It is an alternative to editors like Vi and Emacs and is considered more straightforward for beginners due to its simple and intuitive interface. |
||||
|
||||
Nano comes pre-installed with many Linux distributions and can be used for various tasks, such as writing scripts, editing configuration files, or taking quick notes. With its interactive command line interface, Nano offers a unique blend of usability and functionality. |
||||
|
||||
To use Nano to edit or create files in Linux, the following command can be used: |
||||
|
||||
```bash |
||||
nano filename |
||||
``` |
||||
|
||||
This command opens the named file or creates a new one if it doesn't exist yet. All the editing is done within the terminal itself. While using Nano, the command options are always visible at the bottom of the screen, making it an excellent choice for Linux beginners or those preferring straightforward text editing tools. |
||||
@ -1 +1,13 @@ |
||||
# Editing files |
||||
# Editing Files |
||||
|
||||
Linux, like other operating systems, allows file editing for numerous purposes, whether you need to configure some system functionality or writing scripts. There's a variety of text editors available in Linux by default, these include: `nano`, `vi/vim`, `emacs`, and `gedit`. Each of these has its own learning curve and set of commands. |
||||
|
||||
For instance, `nano` is a basic text editor, which is easy to use and perfect for simple text file editing. `Vi/vim`, on the other hand, is more advanced and offers a wide range of features and commands. |
||||
|
||||
To edit a file you first need to open it using a command like: |
||||
|
||||
```bash |
||||
nano filename |
||||
``` |
||||
|
||||
This command will open the file `filename` in the `nano` editor. Once open, you can make changes to the file, save, and exit it. Other editors like `vi/vim` and `emacs` have their own specific commands for editing, saving and exiting files. It's essential to learn the basic commands of your chosen editor to efficiently work with files in Linux. |
||||
@ -1 +1,12 @@ |
||||
# Command path |
||||
# Command Path in Shell Basics |
||||
|
||||
In Linux, the command path is an important concept under shell basics. Simply put, command path is a variable that is used by the shell to determine where to look for the executable files to run. Linux commands are nothing but programs residing in particular directories. But, one does not have to navigate to these directories every time to run these programs. The command path comes to the rescue! |
||||
|
||||
Usually, when you type a command in the terminal, the shell needs to know the absolute path of the command's executable to run it. Instead of typing the full path each time, command paths allow the shell to automatically search the indicated directories in the correct order. These paths are stored in the $PATH environment variable. |
||||
|
||||
```sh |
||||
echo $PATH |
||||
``` |
||||
Running this command in a Linux terminal will return all the directories that the shell will search, in order, to find the command it has to run. The directories are separated by a colon. |
||||
|
||||
This feature makes using Linux command-line interface convenient and efficient. |
||||
@ -1 +1,19 @@ |
||||
# Environment variables |
||||
# Environment Variables Under Shell Basics |
||||
|
||||
In Linux, environment variables are dynamic named values that can affect the behavior of running processes in a shell. They exist in every shell session. A shell session's environment includes, but is not limited to, the user's home directory, command search path, terminal type, and program preferences. |
||||
|
||||
Environment variables help to contribute to the fantastic and customizable flexibility you see in Unix systems. They provide a simple way to share configuration settings between multiple applications and processes in Linux. |
||||
|
||||
You can use the 'env' command to list all the environment variables in a shell session. If you want to print a particular variable, such as the PATH variable, you can use the 'echo $PATH' command. |
||||
|
||||
Here's an example of how you would do that: |
||||
|
||||
```bash |
||||
# List all environment variables |
||||
$ env |
||||
|
||||
# Print a particular variable like PATH |
||||
$ echo $PATH |
||||
``` |
||||
|
||||
Remember, every shell, such as Bourne shell, C shell, or Korn shell in Unix or Linux has different syntax and semantics to define and use environment variables. |
||||
@ -1 +1,17 @@ |
||||
# Command help |
||||
# Command Help |
||||
|
||||
Command help in Linux is an essential feature that enables users to navigate through Linux shell commands with ease. This feature displays brief information on how to use these commands. For instance, typing 'man' before any command brings up the manual entry for that command which explains what the command does, its syntax and the available options. Another popular command is 'help' which is more suited for shell built-in functions, giving a brief description about each. These command line services are extremely beneficial for beginners trying to learn how to use the Linux shell, as well as seasoned users who may need to look up the specifics of seldom used commands. |
||||
|
||||
To view the manual entry for any command, use: |
||||
|
||||
```bash |
||||
man [command] |
||||
``` |
||||
|
||||
For built-in shell functions, use: |
||||
|
||||
```bash |
||||
help [command] |
||||
``` |
||||
|
||||
Remember, Linux is case sensitive so be sure to type commands precisely. |
||||
@ -1 +1,17 @@ |
||||
# Redirects |
||||
# Redirects In Shell Basics |
||||
|
||||
The shell in Linux provides a robust way of managing input and output streams of a command or program, this mechanism is known as Redirection. Linux being a multi-user and multi-tasking operating system, every process typically has 3 streams opened: |
||||
|
||||
- Standard Input (stdin) - This is where the process reads its input from. The default is the keyboard. |
||||
- Standard Output (stdout) - The process writes its output to stdout. By default, this means the terminal. |
||||
- Standard Error (stderr) - The process writes error messages to stderr. This also goes to the terminal by default. |
||||
|
||||
Redirection in Linux allows us to manipulate these streams, advancing the flexibility with which commands or programs are run. Besides the default devices (keyboard for input and terminal for output), the I/O streams can be redirected to files or other devices. |
||||
|
||||
For example, if you want to store the output of a command into a file instead of printing it to the console, we can use the '>' operator. |
||||
|
||||
```bash |
||||
ls -al > file_list.txt |
||||
``` |
||||
|
||||
This command will write the output of 'ls -al' into 'file_list.txt', whether or not the file initially existed. It will be created if necessary, and if it already exists – it will be overwritten. |
||||
|
||||
@ -1 +1,17 @@ |
||||
# Super user |
||||
# Super User |
||||
|
||||
The Super User, also known as "root user", represents a user account in Linux with extensive powers, privileges, and capabilities. This user has complete control over the system and can access any data stored on it. This includes the ability to modify system configurations, change other user's passwords, install software, and perform more administrative tasks in the shell environment. |
||||
|
||||
The usage of super user is critical to operating a Linux system properly and safely as it can potentially cause serious damage. The super user can be accessed through the `sudo` or `su` commands. |
||||
|
||||
Specifically, `su` switches the current user to the root, whereas `sudo` allows you to run a command as another user, default being root. However, they also have a key difference which is `sudo` will log the commands and its arguments which can be a handy audit trail. |
||||
|
||||
```bash |
||||
# This would prompt for root password and switch you to root usermode |
||||
$ su - |
||||
|
||||
# To perform a command as superuser (if allowed in sudoers list) |
||||
$ sudo <command> |
||||
``` |
||||
|
||||
Note that super user privileges should be handled with care due to their potential to disrupt the system's functionality. Mistaken changes to key system files or unauthorized access can lead to severe issues. |
||||
@ -1 +1,11 @@ |
||||
# Shell basics |
||||
# Linux Shell Basics |
||||
|
||||
The Linux shell is a command-line interface or terminal used to interact directly with the operating system. The shell helps facilitate system commands and acts as an intermediary interface between the user and the system's kernel. The shell can perform complex tasks efficiently and quickly. There are many types of shells available in Linux, including the Bourne Shell (sh), the C Shell (csh), and the Bourne-Again Shell (bash). |
||||
|
||||
The basics of using a Linux shell include navigating between directories, creating, renaming and deleting files and directories, and executing system commands. This introductory level knowledge is crucial for Linux system administration, scripting, and automation. |
||||
|
||||
Here is a classic `bash` command as an example, which prints the current directory: |
||||
|
||||
```bash |
||||
pwd |
||||
``` |
||||
@ -1 +1,17 @@ |
||||
# Permissions |
||||
# Linux File Permissions |
||||
|
||||
In Linux systems, rights and privileges are assigned to files and directories in the form of permissions. These permissions indicate who can read, write, or execute (run) them. In Linux, there are three types of users: owners, groups, and others who can have a different set of permissions. |
||||
|
||||
In fact, permissions on the system are there for a reason: to prevent unprivileged users from making changes on the system that would ultimately affect other users. With adequate permissions, unprivileged users are able to make changes that would be beneficial or harmless to the Linux system. |
||||
|
||||
Let's have a look at an example: |
||||
|
||||
```bash |
||||
-rwxr--r-- 1 root root 4096 Jan 1 12:00 filename |
||||
``` |
||||
|
||||
From the above example, the first character `-` indicates if it is a regular file(`-`) or directory(`d`). The following group of three characters(`rwx`) represents the permissions for the file owner. The next three characters(`r--`) represent permissions for the group and the last set of three characters(`r--`) represents permissions for others. |
||||
|
||||
The `r` indicates that the file can be read, `w` indicates that the file can be written to, and `x` indicates that the file can be executed. |
||||
|
||||
The permissions can be changed using the `chmod`, `chown`, and `chgrp` commands. |
||||
@ -1 +1,22 @@ |
||||
# Archiving |
||||
|
||||
Linux offers powerful utilities for archiving, where multiple files and directories are combined into a single file, primarily for backup and simplification of distribution. The main tools used for this purpose are `tar`, `gzip`, and `bzip2`. |
||||
|
||||
The `tar` command, originally for tape archiving, is a versatile tool that can manage and organize files into one archive. Meanwhile, `gzip` and `bzip2` are used for file compression, reducing the file size and making data transmission easier. |
||||
|
||||
Take a look at the following commands in use: |
||||
|
||||
```bash |
||||
# To create a tar archive: |
||||
tar cvf archive_name.tar directory_to_archive/ |
||||
|
||||
# To extract a tar archive: |
||||
tar xvf archive_name.tar |
||||
|
||||
# To create a gzip compressed tar archive: |
||||
tar cvzf archive_name.tar.gz directory_to_archive/ |
||||
|
||||
#To create a bzip2 compressed tar archive: |
||||
tar cvjf archive_name.tar.bz2 directory_to_archive/ |
||||
``` |
||||
Remember, in Linux, archiving and compression are separate processes, hence `tar` to archive and `gzip`/`bzip2` to compress. Although they're commonly used together, they can very much be used separately as per the requirements. |
||||
|
||||
@ -1 +1,17 @@ |
||||
# Copying renaming |
||||
# Copying and Renaming Files |
||||
|
||||
In Linux, working with files is a daily operation. Whether you are a system administrator, a developer or a regular user, there are tasks where you need to copy, rename, or perform similar actions with files and directories. |
||||
|
||||
To copy files, we utilize the `cp` command. It stands for "copy" and operates on two primary arguments: the file you want to copy and the location where you want it copied. For instance: |
||||
|
||||
```bash |
||||
cp /path/to/original/file /path/to/copied/file |
||||
``` |
||||
|
||||
On the other hand, to rename or move files, we use the `mv` command. The `mv` command stands for "move". Similar to the `cp` command, it operates on two arguments being the file you want to rename or move and the file or directory you want to rename or move it to. This would look something like: |
||||
|
||||
```bash |
||||
mv /path/to/original/file /path/to/new/file |
||||
``` |
||||
|
||||
Remember that Linux commands are case sensitive so make sure to enter the commands exactly as they are. |
||||
@ -1 +1,19 @@ |
||||
# Soft hard links |
||||
# Soft and Hard Links |
||||
|
||||
In Unix-like operating systems like Linux, soft (symbolic) and hard links are simply references to existing files that allow users to create shortcuts and duplication effects within their file system. |
||||
|
||||
A hard link is a mirror reflection of the original file, sharing the same file data but displaying a different name and inode number. It's vital to note that if the original file is deleted, the hard link still retains the file data. |
||||
|
||||
On the other hand, a soft link, also known as a symbolic link, is more like a shortcut to the original file. It has a different inode number and the file data resides only in the original file. If the original file is removed, the symbolic link breaks and will not work until the original file is restored. |
||||
|
||||
Below is an example of how to create a soft link and a hard link in Linux: |
||||
|
||||
```bash |
||||
# Create a hard link |
||||
ln source_file.txt hard_link.txt |
||||
|
||||
# Create a soft link |
||||
ln -s source_file.txt soft_link.txt |
||||
``` |
||||
|
||||
Please, understand that `source_file.txt` is the original file and `hard_link.txt` & `soft_link.txt` are the hard and soft links respectively. |
||||
@ -1 +1,15 @@ |
||||
# Working with files |
||||
# Working with Files |
||||
|
||||
Working with files is an essential part of Linux and it's a skill every Linux user must have. In Linux, everything is considered a file: texts, images, systems, devices, and directories. |
||||
Linux provides multiple command-line utilities to create, view, move or search files. Some of the basic commands for file handling in Linux terminal include `touch` for creating files, `mv` for moving files, `cp` for copying files, `rm` for removing files, and `ls` for listing files and directories. |
||||
|
||||
For instance, to create a file named "example.txt", we use the command: |
||||
```bash |
||||
touch example.txt |
||||
``` |
||||
|
||||
To list files in the current directory, we use the command: |
||||
```bash |
||||
ls |
||||
``` |
||||
Knowing how to effectively manage and manipulate files in Linux is crucial for administering and running a successful Linux machine. |
||||
@ -1 +1,13 @@ |
||||
# Stdout in err |
||||
# Stdout and stderr |
||||
|
||||
The concepts of stdout and stderr in Linux belong to the fundamentals of Linux text processing. In Linux, when a program is executed, three communication channels are typically opened, namely, STDIN (Standard Input), STDOUT (Standard Output), and STDERR (Standard Error). |
||||
|
||||
Each of these channels has a specific function. STDOUT is the channel through which the output from most shell commands is sent. STDERR, on the other hand, is used specifically for sending error messages. This distinction is very useful when scripting or programming, as it allows you to handle normal output and error messages in different manners. |
||||
|
||||
Here is an example code snippet showing how these channels are used: |
||||
|
||||
```bash |
||||
$ command > stdout.txt 2>stderr.txt |
||||
``` |
||||
|
||||
In this example, the ">" operator redirects the standard output (stdout) into a text file named stdout.txt, while "2>" redirects the standard error (stderr) into stderr.txt. This way, normal output and error messages are separately stored in distinct files for further examination or processing. |
||||
@ -1 +1,19 @@ |
||||
# Cut |
||||
# Cut Command |
||||
|
||||
The `cut` command is a text processing utility that allows you to cut out sections of each line from a file or output, and display it on the standard output (usually, the terminal). It's commonly used in scripts and pipelines, especially for file operations and text manipulation. |
||||
|
||||
This command is extremely helpful when you only need certain parts of the file, such as a column, a range of columns, or a specific field. For example, with Linux system logs or CSV files, you might only be interested in certain bits of information. |
||||
|
||||
A basic syntax of `cut` command is: |
||||
|
||||
``` |
||||
cut OPTION... [FILE]... |
||||
``` |
||||
|
||||
Here's an example of how you might use the `cut` command in Linux: |
||||
|
||||
```bash |
||||
echo "one,two,three,four" | cut -d "," -f 2 |
||||
``` |
||||
|
||||
This command will output the second field (`two`) by using the comma as a field delimiter (`-d ","`). |
||||
@ -1 +1,11 @@ |
||||
# Paste |
||||
|
||||
In Linux, paste is a powerful text processing utility that is primarily used for merging lines from multiple files. It allows users to combine data by columns rather than rows, adding immense flexibility to textual data manipulation. Users can choose a specific delimiter for separating columns, providing a range of ways to format the output. |
||||
|
||||
A common use case of the paste command in Linux is the combination of two text files into one, like shown in the example snippet below. |
||||
|
||||
```bash |
||||
paste file1.txt file2.txt > combined.txt |
||||
``` |
||||
|
||||
Over the years, this command has proved to be critical in Linux file processing tasks due to its efficiency, and simplicity. |
||||
@ -1 +1,17 @@ |
||||
# Sort |
||||
|
||||
Linux provides a variety of tools for processing and manipulating text files, one of which is the sort command. The `sort` command in Linux is used to sort the contents of a text file, line by line. The command uses ASCII values to sort files. You can use this command to sort the data in a file in a number of different ways such as alphabetically, numerically, reverse order, or even monthly. The sort command takes a file as input and prints the sorted content on the standard output (screen). |
||||
|
||||
Here is a basic usage of the `sort` command: |
||||
|
||||
```bash |
||||
sort filename.txt |
||||
``` |
||||
|
||||
This command prints the sorted content of the filename.txt file. The original file content remains unchanged. In order to save the sorted contents back into the file, you can use redirection: |
||||
|
||||
```bash |
||||
sort filename.txt > sorted_filename.txt |
||||
``` |
||||
|
||||
This command sorts the content of filename.txt and redirects the sorted content into sorted_filename.txt. |
||||
@ -1 +1,11 @@ |
||||
# Tr |
||||
# Tr-Command |
||||
|
||||
The `tr` command in Linux is a command-line utility that translates or substitutes characters. It reads from the standard input and writes to the standard output. Although commonly used for translation applications, `tr` has versatile functionality in the text processing aspect of Linux. Ranging from replacing a list of characters, to deleting or squeezing character repetitions, `tr` presents a robust tool for stream-based text manipulations. |
||||
|
||||
Here's a basic usage example: |
||||
|
||||
```bash |
||||
echo 'hello' | tr 'a-z' 'A-Z' |
||||
``` |
||||
|
||||
In this example, `tr` is used to convert the lowercase 'hello' to uppercase 'HELLO'. It's an essential tool for text processing tasks in the Linux environment. |
||||
@ -1 +1,12 @@ |
||||
# Head |
||||
# Head Command |
||||
|
||||
The `head` command in Linux is a text processing utility that allows a user to output the first part (or the "head") of files. It is commonly used for previewing the start of a file without loading the entire document into memory, which can act as an efficient way of quickly examining the data in very large files. By default, the `head` command prints the first 10 lines of each file to standard output, which is the terminal in most systems. |
||||
|
||||
```bash |
||||
head file.txt |
||||
``` |
||||
The number of output lines can be customized using an option. For example, to display first 5 lines, we use `-n` option followed by the number of lines: |
||||
|
||||
```bash |
||||
head -n 5 file.txt |
||||
``` |
||||
@ -1 +1,11 @@ |
||||
# Tail |
||||
# Tail Command |
||||
|
||||
The `tail` command in Linux is a utility used in text processing. Fundamentally, it's used to output the last part of the files. The command reads data from standard input or from a file and outputs the last `N` bytes, lines, blocks, characters or words to the standard output (or a different file). By default, `tail` returns the last 10 lines of each file to the standard output. This command is common in situations where the user is interested in the most recent entries in a text file, such as log files. |
||||
|
||||
Here is an example of tail command usage: |
||||
|
||||
```bash |
||||
tail /var/log/syslog |
||||
``` |
||||
|
||||
In the above example, the `tail` command will print the last 10 lines of the `/var/log/syslog` file. This is particularly useful in checking the most recent system log entries. |
||||
@ -1 +1,13 @@ |
||||
# Join |
||||
# join Command in Text Processing on Linux |
||||
|
||||
`join` is a powerful text processing command in Linux. It lets you combine lines of two files on a common field, which works similar to the 'Join' operation in SQL. It's particularly useful when you're dealing with large volumes of data. Specifically, `join` uses the lines from two files to form lines that contain pairs of lines related in a meaningful way. |
||||
|
||||
For instance, if you have two files that have a list of items, one with costs and the other with quantities, you can use `join` to combine these two files so each item has a cost and quantity on the same line. |
||||
|
||||
```bash |
||||
# Syntax |
||||
join file1.txt file2.txt |
||||
``` |
||||
|
||||
Please note that `join` command works properly only when the files are sorted. |
||||
It's crucial to understand all the provided options and flags to use `join` effectively in text processing tasks. |
||||
@ -1 +1,19 @@ |
||||
# Split |
||||
# Linux Text Processing: Split Command |
||||
|
||||
Linux provides an extensive set of tools for manipulating text data. One of such utilities is the `split` command that is used, as the name suggests, to split large files into smaller files. The `split` command in Linux divides a file into multiple equal parts, based on the lines or bytes specified by the user. |
||||
|
||||
It's a useful command because of its practical applicability. For instance, if you have a large data file that can't be used efficiently because of its size, then the split command can be used to break up the file into more manageable pieces. |
||||
|
||||
The basic syntax of the `split` command is: |
||||
|
||||
```bash |
||||
split [options] [input [prefix]] |
||||
``` |
||||
|
||||
By default, the `split` command divides the file into smaller files of 1000 lines each. If no input file is provided, or if it is given as -, it reads from standard input. |
||||
|
||||
For example, to split a file named 'bigfile.txt' into files of 500 lines each, the command would be: |
||||
|
||||
```bash |
||||
split -l 500 bigfile.txt |
||||
``` |
||||
@ -1 +1,11 @@ |
||||
# Pipe |
||||
# Pipe Commands |
||||
|
||||
The pipe (`|`) is a powerful feature in Linux used to connect two or more commands together. This mechanism allows output of one command to be "piped" as input to another. With regards to text processing, using pipe is especially helpful since it allows you to manipulate, analyze, and transform text data without the need to create intermediary files or programs. |
||||
|
||||
Here is a simple example of piping two commands, `ls` and `grep`, to list all the text files in the current directory: |
||||
|
||||
```bash |
||||
ls | grep .txt |
||||
``` |
||||
|
||||
In this example, `ls` lists the files in the current directory and `grep .txt` filters out any files that don't end with `.txt`. The pipe command, `|`, takes the output from `ls` and uses it as the input to `grep .txt`. The output of the entire command is the list of text files in the current directory. |
||||
@ -1 +1,11 @@ |
||||
# Tee |
||||
# Tee in Text Processing |
||||
|
||||
`tee` is a widely used command in Linux systems, falling under the category of text processing tools. It performs a dual function: the command reads from the standard input and writes to standard output and files. This operation gets its name from the T-splitter in plumbing, which splits the flow into two directions, paralleling the function of the `tee` command. |
||||
|
||||
The basic syntax of `tee` under text processing in Linux is: |
||||
|
||||
```bash |
||||
command | tee file |
||||
``` |
||||
|
||||
In this construction 'command' represents the command from which `tee` reads the output, and 'file' signifies the file where `tee` writes the output. It's an extremely useful command for users who want to document their terminal undertakings as it enables both reviewing the result in the terminal and storing the output in the file simultaneously. |
||||
@ -1 +1,11 @@ |
||||
# Nl |
||||
# Introduction to NL (Number Lines) |
||||
|
||||
`nl` command in Linux is a utility for numbering lines in a text file. Also known as 'number lines', it can be handy when you need an overview where certain lines in a file are located. By default, nl number the non-empty lines only, but this behavior can be modified based on user's needs. |
||||
|
||||
It follows a syntax like this: |
||||
|
||||
```bash |
||||
nl [options] [file_name] |
||||
``` |
||||
|
||||
If no file is specified, `nl` will wait for input from user's terminal (stdin). Its clear and readable output makes it a valuable part of any Linux user's text processing toolkit. |
||||
@ -1 +1,11 @@ |
||||
# Wc |
||||
# WC - Text Processing |
||||
|
||||
The `wc` command is a commonly used tool in Unix or Linux that allows users to count the number of bytes, characters, words, and lines in a file or in data piped from standard input. The name `wc` stands for 'word count', but it can do much more than just count words. Common usage of `wc` includes tracking program output, counting code lines, and more. It's an invaluable tool for analyzing text at both granular and larger scales. |
||||
|
||||
Below is a basic usage example for `wc` in Linux: |
||||
|
||||
```bash |
||||
wc myfile.txt |
||||
``` |
||||
|
||||
This command would output the number of lines, words, and characters in `myfile.txt`. The output is displayed in the following order: line count, word count, character count, followed by the filename. |
||||
|
||||
@ -1 +1,18 @@ |
||||
# Expand |
||||
# Expand in Text Processing |
||||
|
||||
Expand is a command-line utility in Unix and Unix-like operating systems that converts tabs into spaces. It can be an essential tool while working with file outputs where the formatting can get disturbed due to tabs. This can be especially useful when working with Linux shell scripts, where the tab space might differ on different systems or text editors, resulting in inconsistent formatting. Consistent indentation using space can greatly enhance code readability. |
||||
|
||||
The `expand` command by default converts tabs into 8 spaces. Here is an example usage: |
||||
|
||||
```bash |
||||
expand filename |
||||
``` |
||||
|
||||
In this example, `filename` is the name of the file you want to convert tabs into spaces in. Once the command is run, the tab-converted content will be printed to standard output. |
||||
|
||||
For specifying the number of spaces for each tab, the `-t` option can be used as follows: |
||||
```bash |
||||
expand -t 4 filename |
||||
``` |
||||
|
||||
In this example, each tab character in `filename` will be replaced with 4 spaces. The output would then be displayed on the console. |
||||
|
||||
@ -1 +1,11 @@ |
||||
# Unexpand |
||||
# Unexpand in Text Processing |
||||
|
||||
The `unexpand` command in Linux is a significant tool when dealing with text processing. It is mostly used to convert spaces into tabs in a file or output from the terminal. This command works by replacing spaces with tabs, making a document or output more coherent and neat. It is primarily used to format the structure, particularly in programming scripts, where indenting with tabs is a common practice. |
||||
|
||||
An example of using the `unexpand` command: |
||||
|
||||
```bash |
||||
unexpand -t 4 file.txt |
||||
``` |
||||
|
||||
The "-t 4" switch tells unexpand to replace every four spaces in `file.txt` with a tab. |
||||
@ -1 +1,11 @@ |
||||
# Uniq |
||||
|
||||
In Linux, `uniq` is an extremely useful command-line program for text processing. It aids in the examination and manipulation of text files by comparing or filtering out repeated lines that are adjacent. Whether you're dealing with a list of data or a large text document, the `uniq` command allows you to find and filter out duplicate lines, or even provide a count of each unique line in a file. It's important to remember that `uniq` only removes duplicates that are next to each other, so to get the most out of this command, data is often sorted using the `sort` command first. |
||||
|
||||
An example of using `uniq` would be: |
||||
|
||||
```bash |
||||
sort names.txt | uniq |
||||
``` |
||||
|
||||
In this example, `names.txt` is a file containing a list of names. The `sort` command sorts all the lines in the file, and then the `uniq` command removes all the duplicate lines. The resulting output would be a list of unique names from `names.txt`. |
||||
@ -1 +1,13 @@ |
||||
# Grep |
||||
# GREP in Text Processing |
||||
|
||||
GREP (Global Regular Expression Print) is considered a significant tool in text processing area on Unix-like operating systems including Linux. It is a powerful utility that searches and filters text matching a given pattern. When it identifies a line that matches the pattern, it prints the line to the screen, offering an effective and a codified way to find text within files. |
||||
|
||||
An essential part of many shell scripts, bash commands, and command-line operations, GREP is a versatile tool that comes pre-installed with every Linux distribution. It embodies three main parts - format, action and regex. Over the years, it had been effectively utilized in multiple programming languages and data science applications. |
||||
|
||||
Here is an example of a simple GREP command: |
||||
|
||||
```bash |
||||
grep "pattern" fileName |
||||
``` |
||||
|
||||
This command will search for the specified pattern within the file and prints the line to the terminal. |
||||
@ -1 +1,15 @@ |
||||
# Awk |
||||
# awk - Text Processing |
||||
|
||||
awk is a powerful text-processing language that is widely used in Unix-like operating systems, including Linux. Named after its three original developers - Alfred Aho, Peter Weinberger, and Brian Kernighan, awk is adept at performing operations upon text files, such as sorting, filtering, and report generation. |
||||
|
||||
The language comprises a set of commands within a script that define pattern-action pairs. Essentially, awk reads an input file line by line, identifies patterns that match what is specified in the script, and consequently executes actions upon those matches. |
||||
|
||||
Though a complete language with variables, expressions, and control structures, awk is most commonly used as a single-line command within bash shell scripts, leveraging its versatile text manipulation capabilities. |
||||
|
||||
Here's an example of how to print first two fields of each line of a file using awk: |
||||
|
||||
```awk |
||||
awk '{print $1,$2}' filename |
||||
``` |
||||
|
||||
This would display the first and second field (typically separated by spaces) of every line in 'filename'. |
||||
@ -1 +1,17 @@ |
||||
# Text processing |
||||
# Text Processing |
||||
|
||||
Text processing is an essential task for system administrators and developers. Linux, being a robust operating system, provides powerful tools for text searching, manipulation, and processing. |
||||
|
||||
Users can utilize commands like `awk`, `sed`, `grep`, and `cut` for text filtering, substitution, and handling regular expressions. Additionally, the shell scripting and programming languages such as Python and Perl also provide remarkable text processing capabilities in Linux. |
||||
|
||||
Although being primarily a command-line operating system, Linux also offers numerous GUI-based text editors including `gedit`, `nano`, and `vim`, which make text editing convenient for both beginners and advanced users. |
||||
|
||||
Below is a simple example using `grep` command to search for the term "Linux" in a file named "sample.txt". |
||||
|
||||
```bash |
||||
grep 'Linux' sample.txt |
||||
``` |
||||
|
||||
This command will display all the lines in the sample.txt file which contain the word "Linux". |
||||
|
||||
Overall, the proficiency in text processing is crucial for Linux users as it allows them to automate tasks, parse files, and mine data efficiently. |
||||
@ -1 +1,16 @@ |
||||
# Uptime load |
||||
# Uptime Load |
||||
|
||||
When managing a Linux server, one critical metric deserving close scrutiny is the "uptime". The `uptime` command in Linux gives information about how long the system has been running without shutting down or restarting, and the system load average. |
||||
|
||||
The system load average is an important indicator that illustrates the amount of computational work that a computer system performs. It's a reflection of how many processes are waiting in line to get CPU time. The system load average is typically shown for 1, 5, and 15 minutes durations. |
||||
|
||||
By consistently analyzing the uptime and load on a Linux server, administrators can identify system usage patterns, diagnose possible performance issues, and determine an efficient capacity planning strategy. If a server has a high load average, it may suggest that the system resources are not sufficient or are misconfigured, leading to possible slow performance or system unresponsiveness. |
||||
|
||||
Here is an example of the `uptime` command and its output: |
||||
|
||||
```bash |
||||
$ uptime |
||||
10:58:35 up 2 days, 20 min, 1 user, load average: 0.00, 0.01, 0.05 |
||||
``` |
||||
|
||||
In the output above, "2 days, 20 min" tells us how long the system has been up, while "0.00, 0.01, 0.05" shows the system's load average over the last one, five, and fifteen minutes, respectively. |
||||
@ -1 +1,13 @@ |
||||
# Auth logs |
||||
# Auth Logs |
||||
|
||||
When dealing with a Linux server and its maintenance, one of the most critical components to regularly review is the auth logs. These logs, usually located in /var/log/auth.log (for Debian-based distributions) or /var/log/secure (for Red Hat and CentOS), record all authentication-related events and activities which have occurred on the server. This includes, among others, system logins, password changes, and issued sudo commands. |
||||
|
||||
Auth logs are an invaluable tool for monitoring and analyzing the security of your Linux server. They can indicate brute force login attacks, unauthorized access attempts, and any suspicious behavior. Regular analysis of these logs is a fundamental task in ensuring server security and data integrity. |
||||
|
||||
Here is an example of how you can use the `tail` command to view the last few entries of the authentication log: |
||||
|
||||
```bash |
||||
tail /var/log/auth.log |
||||
``` |
||||
|
||||
Get yourself familiar with reading and understanding auth logs, as it's one essential way to keep your server secure. |
||||
@ -1 +1,14 @@ |
||||
# Services running |
||||
# Services Running |
||||
|
||||
Linux servers are popular for their stability and flexibility, factors that make them a preferred choice for businesses and organizations when it comes to managing various services. Services that run under a Linux server can range from web services to database services, DNS servers, mail servers, and many others. |
||||
|
||||
As a Linux system administrator, it's important to periodically review these running services to manage resources, check their statuses, and troubleshoot issues, ensuring the health and performance of the server. |
||||
|
||||
Linux has a variety of tools to achieve this, such as: `systemctl`, `service`, `netstat`, `ss` and `lsof`. |
||||
|
||||
For example, the command `systemctl` is widely used on Linux systems to list all running services: |
||||
|
||||
```bash |
||||
systemctl --type=service |
||||
``` |
||||
This command will show a list of all active services along with their current status. It is a necessity for server management and should be part of any Linux system administrator's toolbox. |
||||
@ -1 +1,14 @@ |
||||
# Available mem |
||||
# Evaluating Available Memory |
||||
|
||||
When running several applications in a Linux environment, constant tracking of system health is crucial for smooth operations. Evaluating available memory as part of a server review is a common practice for system administrators. This involves using various command-line tools provided by Linux, such as `free`, `vmstat`, and `top`. These can assist in monitoring memory usage and performance metrics, ensuring systems are not overloaded, and adequate resources are available for important applications. |
||||
|
||||
The `free` command, for instance, gives a summary of the overall memory usage including total used and free memory, swap memory and buffer/cache memory. Here's an example: |
||||
|
||||
```bash |
||||
$ free -h |
||||
total used free shared buff/cache available |
||||
Mem: 15Gi 10Gi 256Mi 690Mi 5.3Gi 4.2Gi |
||||
Swap: 8.0Gi 1.3Gi 6.7Gi |
||||
``` |
||||
|
||||
In this output, the '-h' option is used to present the results in a human-readable format. Understanding the state of memory usage in your Linux server can help maintain optimal server performance and troubleshoot any potential issues. |
||||
@ -1 +1,18 @@ |
||||
# Server review |
||||
# Server Review |
||||
|
||||
The process of reviewing a server in Linux involves assessing the server's performance, security, and configuration to identify areas of improvement or any potential issues. The scope of the review can include checking security enhancements, examining log files, reviewing user accounts, analyzing the server’s network configuration, and checking its software versions. |
||||
|
||||
Linux, known for its stability and security, has become a staple on the back-end of many networks and servers worldwide. Depending on the distribution you are using, Linux offers multiple tools and commands to perform comprehensive server reviews. |
||||
|
||||
```bash |
||||
# A command often used for showing memory information |
||||
free -m |
||||
|
||||
# A command for showing disk usage |
||||
df -h |
||||
|
||||
# A command for showing CPU load |
||||
uptime |
||||
``` |
||||
|
||||
It is a critical task for System Administrators and DevOps professionals to routinely conduct server reviews to ensure the server's optimal performance, security, and reliability. |
||||
@ -1 +1,26 @@ |
||||
# Bg fg processes |
||||
# Managing bg (background) and fg (foreground) Processes |
||||
|
||||
In Linux environment, a process can be run in either the foreground (fg) or the background (bg). The foreground process takes input directly from the user, displaying output and errors to the user's terminal. On the other hand, a background process runs independently of the user's actions, freeing up the terminal for other tasks. |
||||
|
||||
Typically, a process starts in the foreground. However, you can send it to the background by appending an ampersand (&) to the command or by using the `bg` command. Conversely, the `fg` command brings a background process to the foreground. |
||||
|
||||
Here's how you can send a running process to background: |
||||
|
||||
```bash |
||||
command & |
||||
``` |
||||
|
||||
Or if a process is already running: |
||||
|
||||
```bash |
||||
CTRL + Z # This will pause the process |
||||
bg # This resumes the paused process in the background |
||||
``` |
||||
|
||||
And to bring it back to the foreground: |
||||
|
||||
```bash |
||||
fg |
||||
``` |
||||
|
||||
These commands, `bg` and `fg` are part of job control in Unix-like operating systems, which lets you manage multiple tasks simultaneously from a single terminal. |
||||
@ -1 +1,25 @@ |
||||
# Listing finding proc |
||||
# Listing and Finding Processes (proc) |
||||
|
||||
In Linux, processes form the backbone of any functioning system - running various tasks and executing different operations. In order to effectively manage your Linux system, it's crucial to be able to list and find the currently running processes. This aids in monitoring system performance, tracking down any issues, and in controlling resource allocation. |
||||
|
||||
The `proc` filesystem is an extremely powerful tool in this respect. Available in all Unix-like operating systems, `proc` is a virtual file system that provides detailed information about running processes, including its PID, status, and resource consumption. |
||||
|
||||
With commands like `ps`, `top`, and `htop`, we can quickly list out the running processes on the Linux system. Specifically, the `ps` command offers an in-depth snapshot of currently running processes, whereas `top` and `htop` give real-time views of system performance. |
||||
|
||||
```bash |
||||
# list all running processes |
||||
ps -ef |
||||
|
||||
# display ongoing list of running processes |
||||
top |
||||
|
||||
# alternatively, for a more user-friendly interface |
||||
htop |
||||
``` |
||||
Exploring the proc directory (`/proc`), we dive even deeper, enabling us to view the system's kernel parameters and each process's specific system details. |
||||
|
||||
```bash |
||||
# view specifics of a particular PID |
||||
cat /proc/{PID}/status |
||||
``` |
||||
In short, 'Finding and Listing Processes (proc)' in Linux is not just a core aspect of process management, but also a necessary skill for enhancing system performance and resolution of issues. |
||||
@ -1 +1,14 @@ |
||||
# Proc signals |
||||
# Proc Signals under Process Management |
||||
|
||||
In Linux, process management is a fundamental part of the system which involves creating, scheduling, terminating and coordinating the execution of processes. One crucial aspect of this is proc signals or process signals. |
||||
|
||||
Process signals are a form of communication mechanism in Unix and Linux systems. They provide a means to notify a process of synchronous or asynchronous events. There are a variety of signals like SIGINT, SIGSTOP, SIGKILL, etc. available which can be sent to a running process to interrupt, pause or terminate it. |
||||
|
||||
For instance, to send a SIGSTOP signal to a process with a PID of 12345 you would use `kill` command in terminal as follows: |
||||
|
||||
```bash |
||||
kill -SIGSTOP 12345 |
||||
``` |
||||
This will suspend the execution of the process until a SIGCONT signal is received. |
||||
|
||||
Understanding proc signals is essential for comprehensive process management and resource allocation in Linux. |
||||
@ -1 +1,13 @@ |
||||
# Kill processes |
||||
# Kill Processes |
||||
|
||||
On any Linux system, whether you're on a server or a desktop system, processes are consistently running. Sometimes, these processes may not behave as expected due to certain reasons like system bugs, unexpected system behavior, or accidental initiation and may require termination. This is where the concept of killing processes in Linux comes to picture under the area of process management. |
||||
|
||||
'Kill' in Linux is a built-in command that is used to terminate processes manually. You can use the `kill` command to send a specific signal to a process. When we use the `kill` command, we basically request a process to stop, pause, or terminate. |
||||
|
||||
Here's a basic illustration on how to use the `kill` command in Linux: |
||||
|
||||
```bash |
||||
kill [signal or option] PID(s) |
||||
``` |
||||
|
||||
In practice, you would identify the Process ID (PID) of the process you want to terminate and replace PID(s) in the above command. The signal or option part is optional, but very powerful allowing for specific termination actions. |
||||
@ -1 +1,19 @@ |
||||
# Proc priorities |
||||
# Proc Priorities Under Process Management |
||||
|
||||
In the Linux environment, every running task or essentially a "process" is assigned a certain priority level that impacts its execution timing. These priorities are instrumental in efficient system resource utilization, enabling Linux to fine-tune execution and allocate system resources smartly. |
||||
|
||||
The Linux kernel sorts processes in the proc structure, typically found under the `/proc` file system directory. This structure contains information about all active processes, including their priorities. The concept of proc priorities under process management refers to the priority accorded to each process by the system. This priority value (also known as "nice" value) ranges from -20 (highest priority) to +19 (lowest priority). |
||||
|
||||
By understanding and managing proc priorities, you can optimize system performance and control which processes receive more or less of the CPU's attention. |
||||
|
||||
Here's a simple command in the Linux terminal to display the process ID, priority, and user for all processes: |
||||
|
||||
```sh |
||||
ps -eo pid,pri,user |
||||
``` |
||||
|
||||
To change the priority of any process, you can use the `renice` command: |
||||
|
||||
```sh |
||||
renice +5 -p [PID] # Increase priority by 5 units for process ID [PID] |
||||
``` |
||||
@ -1 +1,30 @@ |
||||
# Proc forking |
||||
# Process Forking in Process Management |
||||
|
||||
Process forking is a fundamental concept under process management in Linux systems. The term refers to the mechanism where a running process (parent process) can generate a copy of itself (child process), enabling concurrent execution of both processes. This is facilitated by the 'fork' system call. It is a prominent aspect in understanding the creation and control of processes in a Linux environment. |
||||
|
||||
The child process created by fork is a nearly perfect copy of the parent process with exception to just a few values including the process ID and parent process ID. Any changes made in the child process does not affect the parent process, and vice versa. |
||||
|
||||
Here's a basic code snippet of proc forking in C: |
||||
|
||||
```c |
||||
#include<sys/types.h> |
||||
#include<unistd.h> |
||||
#include<stdio.h> |
||||
|
||||
int main() |
||||
{ |
||||
pid_t child_pid; |
||||
|
||||
// Try creating a child process |
||||
child_pid = fork(); |
||||
|
||||
// If a child is successfully created |
||||
if(child_pid >= 0) |
||||
printf("Child created with PID: %d\n", child_pid); |
||||
else |
||||
printf("Fork failed\n"); |
||||
return 0; |
||||
} |
||||
``` |
||||
|
||||
In this snippet, `fork()` is used to created a new child process. If the process creation is successful, fork() returns the process ID of the child process. If unsuccessful, it returns a negative value. |
||||
@ -1 +1,27 @@ |
||||
# Process management |
||||
# Process Management |
||||
|
||||
Process management is integral part of any operating system and Linux is no different. Every program running on Linux, be it an application or a system operation, is treated as a process. These processes perform different tasks but work together to provide a seamless operating experience. |
||||
|
||||
In Linux, users can interact and manage these processes by using different commands for various process management tasks such as viewing the currently running processes, killing processes, changing the priority of a process, and so on. Understanding these commands and how to use them effectively is essential to Linux process management. |
||||
|
||||
The ps command for example, provides information about the currently running processes: |
||||
|
||||
```bash |
||||
ps aux |
||||
``` |
||||
|
||||
This will list out all the currently running processes with information such as the process ID, the user running that process, the CPU and memory it's consuming, the command that started the process, and more. |
||||
|
||||
`top` is another common command. It provides a live, updating view of the current state of the system including processes: |
||||
|
||||
```bash |
||||
top |
||||
``` |
||||
|
||||
Yet another powerful tool is `kill`, which can send specific signals to processes. For example, you can gracefully stop a process with `SIGTERM` (15) or forcefully stop one with `SIGKILL` (9): |
||||
|
||||
```bash |
||||
kill -SIGTERM pid |
||||
kill -SIGKILL pid |
||||
``` |
||||
(note: you replace `pid` with the process ID you want to stop) |
||||
@ -1 +1,17 @@ |
||||
# Create update |
||||
# User Management: Create and Update Users |
||||
|
||||
User management is an essential part of maintaining a Linux system. It consists of managing user accounts and groups, and setting permissions for them. Linux system administrators should be proficient in creating, updating and managing users to ensure system security as well as efficient use of system resources. |
||||
|
||||
When creating a new user, we add a new record in the system files for that user along with other details like home directory, login shell, and password. We can create new users with ‘useradd’ or 'adduser' commands. For instance, to create a new user, you might use a command like: |
||||
|
||||
```bash |
||||
sudo useradd newuser |
||||
``` |
||||
|
||||
On the other hand, updating a user means modifying user details. It may include changing display or user name, home directory or login shell. The 'usermod' command is used for updating a user in Linux. For instance, to change the home directory for a user, you might use a command like: |
||||
|
||||
```bash |
||||
sudo usermod -d /new/home/directory username |
||||
``` |
||||
|
||||
Managing users effectively is crucial in Linux for both system security and resource management. You can fully harness the power of Linux's multi-user characteristics through skillful user management. |
||||
@ -1 +1,16 @@ |
||||
# User groups |
||||
# Linux User Groups |
||||
|
||||
In Linux, a User Group is a mechanism used to manage the system’s users and permissions. It represents a collection of users, designed specifically to simplify system administration. Each user in Linux is a part of one or more groups. These groups are primarily used for determining access rights to various system resources, including files, directories, devices, etc. |
||||
|
||||
Understanding and appropriately managing user groups in Linux is crucial for overall system security. It allows the administrator to grant certain privileges to a specific set of users, without granting them complete superuser or 'root' access. |
||||
|
||||
One can check a user’s group affiliations using the `groups` command, while the `/etc/group` file contains a list of all groups on the system. |
||||
|
||||
```bash |
||||
groups [username] |
||||
cat /etc/group |
||||
``` |
||||
|
||||
At times, it becomes necessary to add or remove users from groups, modifications to group properties or even the creation and deletion of groups altogether. These operations can typically be performed using the `groupadd`, `groupdel`, `groupmod`, `usermod`, and `gpasswd` commands. |
||||
|
||||
Overall, user groups are an essential component of Linux User Management, helping to maintain a secure and organized system environment. |
||||
@ -1 +1,29 @@ |
||||
# Permissions |
||||
# Linux: Permissions Under User Management |
||||
|
||||
Linux, like all Unix-like systems, is a multi-user system, meaning it can be used by multiple users at one time. As such, it has a comprehensive system for managing permissions for these users. These Linux permissions dictate who can access, modify, and execute files and directories. |
||||
|
||||
Permissions are categorized into three types: |
||||
|
||||
1. **Read permission**: Users with read permissions can view the contents of the file. |
||||
|
||||
2. **Write permission**: Users with write permissions can modify the contents of the file or directory. |
||||
|
||||
3. **Execute permission**: Users with execute permissions can run a file or traverse a directory. |
||||
|
||||
These permissions can be set for three kinds of entities: |
||||
|
||||
1. **User**: The owner of the file or directory. |
||||
|
||||
2. **Group**: The user group that owns the file or directory. |
||||
|
||||
3. **Others**: Other users who are neither the owner of the file, nor belong to the group that owns the file. |
||||
|
||||
To set these permissions, Linux uses a system of permission bits. This information can be viewed and manipulated using commands such as `chmod`, `chown`, and `chgrp`. |
||||
|
||||
```bash |
||||
chmod 755 my_file |
||||
chown new_owner my_file |
||||
chgrp new_group my_file |
||||
``` |
||||
|
||||
In the example above, `chmod 755 my_file` sets permissions so that the user can read, write, and execute (7), while the group and others can read and execute (5). The `chown` and `chgrp` commands change the owner and group of `my_file`, respectively. |
||||
@ -1 +1,19 @@ |
||||
# User management |
||||
# User Management |
||||
|
||||
Linux operating system offers a structured user management system, allowing multiple users to interact with the same system in an isolated manner. This includes defining user roles, assigning permissions, groups, ownership and other related aspects, which are crucial tasks for Linux administrators. |
||||
|
||||
For smoother and controlled operation, user management in Linux includes tasks such as creating, deleting, modifying users and groups. It also involves assigning permissions and ownership of files and directories to users/groups. |
||||
|
||||
Basic shell commands are a fundamental part of user management in Linux. For example, `adduser` or `useradd` is used to create a new user on a system: |
||||
|
||||
```bash |
||||
sudo adduser newuser |
||||
``` |
||||
|
||||
Similarly, `deluser` or `userdel` is used to remove a user: |
||||
|
||||
```bash |
||||
sudo deluser newuser |
||||
``` |
||||
|
||||
The entire concept of user management circles around providing proper accessibility, and maintaining the security of the Linux operating system. Other commands such as `passwd` for password management or `su` for switching users further emphasize the depth and importance of user management in Linux. |
||||
@ -1 +1,13 @@ |
||||
# Service status |
||||
# Service Status |
||||
|
||||
In Linux, service status is a critical part of service management. It is used to understand the current state of any given service running on a Linux-based system. Services can include network processes, backend servers, or any application running in the background. |
||||
|
||||
The command `systemctl` is the predominantly used command for controlling the `systemd` system and service manager. The `status` command in conjunction with `systemctl` is particularly useful for checking the state of the service. This command allows administrators to query and control the state of a systemd system and service manager. |
||||
|
||||
Here's a simple example of how to use the `systemctl` command to check the status of a service: |
||||
|
||||
```bash |
||||
systemctl status apache2.service |
||||
``` |
||||
This command would give status information about Apache2, the popular web server. |
||||
By managing service statuses efficiently, Linux administrators can diagnose and rectify system problems, maintain optimum performance levels, and prevent service downtimes. |
||||
@ -1 +1,21 @@ |
||||
# Start stop service |
||||
# Start Stop Service |
||||
|
||||
In Linux, Service Management refers to controlling and managing system services, such as firewall, network, database, and other essential services. This play a critical role in the system's functionality and stability. |
||||
|
||||
One of the fundamental parts of service management in Linux is starting and stopping service. System administrators often need to start, stop, or restart services after an update or configuration changes. In Linux, this can be done using the `systemctl` command. |
||||
|
||||
Here is a simple example: |
||||
|
||||
```bash |
||||
# To start a service |
||||
sudo systemctl start service_name |
||||
|
||||
# To stop a service |
||||
sudo systemctl stop service_name |
||||
|
||||
# To restart a service |
||||
sudo systemctl restart service_name |
||||
``` |
||||
|
||||
Replace `service_name` with the name of the service you want to start, stop or restart. Always make sure to use sudo to execute these commands as they require root permissions. |
||||
Please note, these commands will vary based on the specific Linux distribution and the init system it uses. |
||||
@ -1 +1,19 @@ |
||||
# Check logs |
||||
# Checking Logs |
||||
|
||||
Checking Logs Under Service Management in Linux plays a vital role in systems administration and troubleshooting procedures. Logs are fundamental for an in-depth understanding of what's going on inside a Linux system. These records provide a chronological record of events related to your system for use in debugging and troubleshooting problems. |
||||
|
||||
Several essential logs generated by system processes, users and administrator actions can be found in `/var/log` directory. Logs can be accessed and viewed using several commands. For example, the `dmesg` command can be used to display the kernel ring buffer. Most system logs are managed by `systemd` and can be checked using the command `journalctl`. |
||||
|
||||
```shell |
||||
journalctl |
||||
``` |
||||
|
||||
This command will show the entire system log from the boot to the moment you're calling the journal. |
||||
|
||||
To display logs for a specific service, the `-u` option can be used followed by the service’s name. |
||||
|
||||
```shell |
||||
journalctl -u service_name |
||||
``` |
||||
|
||||
Remember, understanding and monitoring your system logs will provide you a clear view of what's going on in your Linux environment. It is a vital skill worth developing to effectively manage and troubleshoot systems. |
||||
@ -1 +1,27 @@ |
||||
# Creating services |
||||
# Creating Services |
||||
|
||||
In Linux, service management refers to starting, stopping, enabling, and managing software services. Understanding how to control services is crucial for controlling a Linux server or desktop. |
||||
|
||||
Typically, a service is an application that runs in the background waiting to be used, or carrying out essential tasks. Common kinds of services include web servers, database servers, and mail servers. |
||||
|
||||
Creating services in Linux would thus refer to the process of setting up these background applications to run and perform the desired tasks. This process often includes writing service files (script) that specify how to start, stop, and restart the service using a service management system. |
||||
|
||||
The most common service management system in modern Linux distributions is systemd. With systemd, services are defined by placing service unit files in specific directories. |
||||
|
||||
For instance, we could create a simple `my_service.service` file: |
||||
|
||||
``` |
||||
[Unit] |
||||
Description=My Custom Service |
||||
After=network.target |
||||
|
||||
[Service] |
||||
ExecStart=/path/to/your/executable |
||||
|
||||
[Install] |
||||
WantedBy=multi-user.target |
||||
``` |
||||
|
||||
This service file can be placed under `/etc/systemd/system/` to make systemd recognize it. You would then control the service using `systemctl`, systemd's command tool. |
||||
|
||||
Note that best practices in Linux dictate that we should not run services as root whenever possible, for security reasons. Instead, we should create a new user to run the service. |
||||
@ -1 +1,19 @@ |
||||
# Service management |
||||
# Service Management |
||||
|
||||
Service Management in Linux refers to the system of controlling the services (or "daemons") that Linux starts and stops during the process of booting up and shutting down your computer. These services perform various functions and provide processes that aren't attached to the user interface. |
||||
|
||||
Linux systems, particularly system administrators, often need to manage these services, such as starting or stopping them, enabling or disabling them at boot time, etc. Various commands involved in service management in Linux include `systemctl start`, `systemctl stop`, `systemctl restart`, `systemctl reload`, `systemctl status`, and `systemctl enable/disable`, among others. |
||||
|
||||
In modern Linux distros, service management is primarily handled by systemd but in older or minimalistic distros, it's handled by older systems like SystemV or Upstart. |
||||
|
||||
Here's a basic example of starting and checking the status of a service (e.g., sshd service) using systemctl: |
||||
|
||||
```bash |
||||
# Start sshd service |
||||
sudo systemctl start sshd |
||||
|
||||
# Check status of sshd service |
||||
sudo systemctl status sshd |
||||
``` |
||||
|
||||
Managing services is a key skill in Linux system administration and essential for maintaining a secure and stable system. |
||||
@ -1 +1,19 @@ |
||||
# Repositories |
||||
# Linux Package Management: Repositories |
||||
|
||||
Package management in Linux involves handling packages or modules of software, streamlining the process of installing, upgrading, and configuring Linux distributions. At the crux of pack management are repositories, critical components that store and manage collections of software packages. |
||||
|
||||
A repository in Linux is a storage location from where the system retrieves and installs the necessary OS updates and applications. These repositories contain thousands of Software Packages or RPM Packages compiled for specific Linux distributions. |
||||
|
||||
The specific repository used depends on the Linux distribution (like Ubuntu, Fedora, etc.) and the package format the distribution uses (like .deb in Debian and Ubuntu or .rpm in Fedora and CentOS). |
||||
|
||||
Repositories provide a method of updating the tools and applications on your Linux system, and they also ensure all updates and dependencies work together and are tested for integration before they are released. |
||||
|
||||
There is no standard way to use the repositories across various distributions, each comes with its pre-configured set of repositories. |
||||
|
||||
``` |
||||
sudo apt update # command to update the repository in Ubuntu |
||||
sudo yum update # command to update the repository in CentOS or Fedora |
||||
raco pkg update # command in Racket to update all installed packages |
||||
``` |
||||
|
||||
These repositories are what make Linux a force to reckon with when it comes to software management with an element of security ensuring that the users only install software that is secure and reliable. |
||||
@ -1 +1,12 @@ |
||||
# Snap |
||||
|
||||
Snap is a modern approach to package management in Linux systems promoted by Canonical (the company behind Ubuntu). Unlike traditional package management systems such as dpkg or RPM, Snap focuses on providing software as self-contained packages (known as 'Snaps') that include all of their dependencies. This ensures that a Snap application runs consistently across a variety of different Linux distributions. |
||||
|
||||
Snaps are installed from a Snapcraft store and are automatically updated in the background. The Snap update process is transactional, meaning if something goes wrong during an update, Snap can automatically revert to the previous working version. |
||||
|
||||
Here is a simple example of a snap command: |
||||
|
||||
```sh |
||||
sudo snap install [package-name] |
||||
``` |
||||
In the command above, `[package-name]` is the name of the snap package you want to install. You must run this command as the superuser (sudo), as root privileges are needed to install packages. |
||||
|
||||
@ -1 +1,21 @@ |
||||
# Finding installing packages |
||||
# Finding and Installing Packages |
||||
|
||||
The ability to efficiently find and install software packages is a fundamental skill when working with Linux based systems. Linux package management tools such as `apt`, `yum`, or `dnf` are used to automate the process of installing, upgrading, configuring, and removing software packages in a consistent manner. |
||||
|
||||
It's important to understand how package management works in Linux, because it significantly simplifies the process of software management, eliminating the need to manually download, compile, and install software from source code. |
||||
|
||||
For example, on a Debian-based system like Ubuntu you would use `apt` or `apt-get` to install a new package like so: |
||||
|
||||
``` |
||||
sudo apt-get update |
||||
sudo apt-get install package-name |
||||
``` |
||||
|
||||
While in a Fedora or CentOS you would use `dnf` or `yum`: |
||||
|
||||
``` |
||||
sudo dnf update |
||||
sudo dnf install package-name |
||||
``` |
||||
|
||||
Note that you should replace `package-name` with the name of the package you want to install. Remember that you will need appropriate permissions (often root) to install packages in a Linux system. |
||||
@ -1 +1,19 @@ |
||||
# Listing installed packages |
||||
# Listing Installed Packages |
||||
|
||||
Linux, known for its robustness and flexibility, provides several package managers that aid in software management. These package managers help us to install, update, or remove software in a systematic way. Each Linux distribution may come with its own package management system. Examples include `apt` in Debian-based systems, `dnf` in Fedora, `zypper` in OpenSUSE, and `pacman` in Arch Linux. |
||||
|
||||
One common task you may often need is listing installed packages in your system. This task can help in various scenarios like auditing installed software, scripting or automating deployment of software on new machines. |
||||
|
||||
Below is the command for listing installed packages in an `apt` package manager: |
||||
|
||||
```shell |
||||
sudo apt list --installed |
||||
``` |
||||
|
||||
For `dnf` package manager, you would use: |
||||
|
||||
```shell |
||||
dnf list installed |
||||
``` |
||||
|
||||
Remember, different distributions will have their own syntax for this command. |
||||
@ -1 +1,13 @@ |
||||
# Install remove ugprade packages |
||||
# Installation, Removal, and Upgrade of Packages |
||||
|
||||
Managing packages in a Linux system is one of the critical tasks that every Linux user and system administrator must be familiar with. Packages in Linux are pre-compiled software modules that include executables and files required to run and use the software. Linux distributions use different package managers such as `apt` for Debian/Ubuntu based distributions, `yum` and `dnf` for Fedora/RHEL/CentOS, and `zypper` for SUSE. |
||||
|
||||
Managing packages includes tasks like installing new software packages, removing unused packages, and upgrading existing packages to newer versions. All these tasks can be performed using command-line instructions specific to each package manager. |
||||
|
||||
A typical package management task such as installing a new package using `apt` would involve executing a command like: |
||||
|
||||
```bash |
||||
sudo apt-get install packagename |
||||
``` |
||||
|
||||
However, the exact command varies depending on the package manager in use. Similarly, removing and upgrading packages also utilize command-line instructions specific to each package manager. Detailed understanding of these tasks is crucial for effective Linux system administration. |
||||
@ -1 +1,13 @@ |
||||
# Package management |
||||
# Package Management |
||||
|
||||
Package Management is a crucial concept in Linux that aids in the handling of packages (collections of files). It not only allows the user to install new software with single commands but also helps manage existing ones. This includes installing, updating, configuring, and removing software packages. Package management incorporates a standardized system that keeps track of every software's prerequisites and takes care of installation, updates and removal. |
||||
|
||||
Linux distributions use various package managers. Some of the commonly used are `apt` (Advanced Packaging Tool) for Debian-based distributions, `yum` (Yellowdog Updater, Modified) and `dnf` (Dandified YUM) for Red-Hat-based distributions, and `pacman` for Arch Linux. |
||||
|
||||
For instance, to install a package in a Debian-based distribution, you would use the following command in apt: |
||||
|
||||
```bash |
||||
sudo apt-get install <package-name> |
||||
``` |
||||
|
||||
Such vital features have made package management systems an integral part of Linux distributions, allowing users to handle applications efficiently. |
||||
@ -1 +1,14 @@ |
||||
# Inodes |
||||
|
||||
In a Linux filesystem, an inode (index node) is a core concept that represents a filesystem object such as a file or a directory. More specifically, an inode is a data structure that stores critical information about a file except its name and actual data. This information includes the file's size, owner, access permissions, access times, and more. |
||||
|
||||
Every file or directory in a Linux filesystem has a unique inode, and each inode is identified by an inode number within its own filesystem. This inode number provides a way of tracking each file, acting as a unique identifier for the Linux operating system. |
||||
|
||||
Whenever a file is created in Linux, it is automatically assigned an inode that stores its metadata. The structure and storage of inodes are handle by the filesystem, which means the kind and amount of metadata in an inode can differ between filesystems. |
||||
|
||||
Although you would not interact with inodes directly in everyday usage, understanding inodes can be very helpful when dealing with advanced file operations, such as creating links or recovering deleted files. |
||||
|
||||
```bash |
||||
# Retrieve the inode of a file |
||||
ls -i filename |
||||
``` |
||||
@ -1 +1,15 @@ |
||||
# Filesystems |
||||
|
||||
Linux operating system provides multiple ways to handle the data storage through the concept of filesystems under disks. Filesystems, in essence, is the way how files are stored and organized on the storage disk. It's a critical component of the system as it ensures the integrity, reliability and efficient access to the data. |
||||
|
||||
A disk installed in a Linux system can be divided into multiple partitions, each with its own filesystem. Linux supports various types of filesystems, such as EXT4, XFS, BTRFS, etc. Each one of them has their own advantages regarding performance, data integrity and recovery options. |
||||
|
||||
Configuration of these filesystems relies on a defined hierarchical structure. All the files and directories start from the root directory, presented by '/'. |
||||
|
||||
Understanding the concept and management of filesystems is key for the successful administration of Linux systems, as it involves routine tasks like mounting/unmounting drives, checking disk space, managing file permissions, and repairing corrupted filesystems. |
||||
|
||||
Code snippet to display the file system in Linux: |
||||
```bash |
||||
df -T |
||||
``` |
||||
This command will display the type of filesystem, along with the disk usage status. |
||||
@ -1 +1,17 @@ |
||||
# Mounts |
||||
|
||||
In Linux environments, a very crucial concept related to disk management is the "mounting" of filesystems. Fundamentally, mounting in Linux refers to the process that allows the operating system to access data stored on underlying storage devices, such as hard drives or SSDs. This process attaches a filesystem (available on some storage medium) to a specific directory (also known as a mount point) in the Linux directory tree. |
||||
|
||||
The beauty of this approach lies in the unified and seamless manner in which Linux treats all files, irrespective of whether they reside on a local disk, network location, or any other kind of storage device. |
||||
|
||||
The `mount` command in Linux is used for mounting filesystems. When a specific filesystem is 'mounted' at a particular directory, the system can begin reading data from the device and interpreting it according to the filesystem's rules. |
||||
|
||||
It's worth noting that Linux has a special directory, `/mnt`, that is conventionally used as a temporary mount point for manual mounting and unmounting operations. |
||||
|
||||
```sh |
||||
mount /dev/sdb1 /mnt |
||||
``` |
||||
|
||||
The above command will mount the filesystem (assuming it's a valid one) on the second partition of a second hard drive at the `/mnt` directory. After the partition is mounted, you can access the files using the `/mnt` directory. |
||||
|
||||
Understanding and managing mounts is crucial for effective Linux disk and filesystem management. |
||||
@ -1 +1,22 @@ |
||||
# Adding disks |
||||
# Adding Disks |
||||
|
||||
In Linux, hard disks and portable drives are managed and controlled through a series of directories and files, commonly referred to as the Linux Filesystem. When you add new disks in Linux, you need to prepare them before they can be used. |
||||
|
||||
The process involves creating partitions on the disk, creating filesystem on the partitions, and then mounting the filesystems to directories in your system’s directory tree. This becomes important especially when working with multiple disk drives or large data storage units in order to create a seamless user experience. |
||||
|
||||
The following are common commands to manage disks: |
||||
|
||||
- Use `lsblk` to list all block devices (disk and partitions). |
||||
- Use `fdisk /dev/sdX` to create a new partition on a disk. |
||||
- Use `mkfs.ext4 /dev/sdX1` to create a new filesystem on a partition. |
||||
- Use `mount /dev/sdX1 /mount/point` to mount a filesystem to a directory. |
||||
|
||||
```shell |
||||
# example commands to add new disk |
||||
lsblk # list all disks and partitions |
||||
sudo fdisk /dev/sdb # let's suppose new disk is /dev/sdb |
||||
sudo mkfs.ext4 /dev/sdb1 # make filesystem(e.g., ext4) on partition 1 |
||||
sudo mount /dev/sdb1 /mnt # mount new filesystem to /mnt directory |
||||
``` |
||||
|
||||
Remember to replace `/dev/sdb` and `/dev/sdb1` with your actual disk and partition identifiers. The mount point `/mnt` may also be replaced with any other directory as per your system's structure and preference. |
||||
@ -1 +1,21 @@ |
||||
# Swap |
||||
# Linux Swap under Disks Filesystems |
||||
|
||||
Swap space in Linux is used when the amount of physical memory (RAM) is full. If the system needs more memory resources and the physical memory is full, inactive pages in memory are moved to the swap space. Swap space is a portion of a hard disk drive (HDD) that is used for virtual memory. |
||||
|
||||
Having swap space ensures that whenever your system runs low on physical memory, it can move some of the data to the swap, freeing up RAM space, but this comes with performance implications as disk-based storage is slower than RAM. |
||||
|
||||
In the context of disks and filesystems, the swap space can live in two places: |
||||
|
||||
1. In its own dedicated partition. |
||||
2. In a regular file within an existing filesystem. |
||||
|
||||
For instance, to add a swap file, we might use the fallocate command to create a certain sized file for swap and the mkswap command to make it suitable for swap usage. |
||||
|
||||
``` |
||||
fallocate -l 1G /swapfile # creates a swap file |
||||
chmod 600 /swapfile # secures the swap file by preventing regular users from reading it |
||||
mkswap /swapfile # sets up the Linux swap area |
||||
swapon /swapfile # enables the file for swapping |
||||
``` |
||||
|
||||
Remember that the decision of where to place your swap space, how much swap space to have, and how to utilize swap space are all important considerations in optimizing your system's performance. |
||||
@ -1 +1,22 @@ |
||||
# Lvm |
||||
# Linux Logical Volume Manager (LVM) |
||||
|
||||
The Linux Logical Volume Manager (LVM) is a device mapper framework that provides logical volume management for the Linux kernel. It was created to ease disk management, allowing for the use of abstracted storage devices, known as logical volumes, instead of using physical storage devices directly. |
||||
|
||||
LVM is extremely flexible, and features include resizing volumes, mirroring volumes across multiple physical disks, and moving volumes between disks without needing to power down. |
||||
|
||||
LVM works on 3 levels: Physical Volumes (PVs), Volume Groups (VGs), and Logical Volumes (LVs). |
||||
|
||||
- PVs are the actual disks or partitions. |
||||
- VGs combine PVs into a single storage pool. |
||||
- LVs carve out portions from the VG to be used by the system. |
||||
|
||||
To create an LVM, you need to follow these steps in Linux: |
||||
|
||||
```bash |
||||
pvcreate /dev/sdb1 |
||||
vgcreate my-vg /dev/sdb1 |
||||
lvcreate -L 10G my-vg -n my-lv |
||||
``` |
||||
In the above commands, we create a physical volume on `/dev/sdb1`, then create a volume group named `my-vg`. Finally, we carve out a 10GB logical volume from the volume group and name it `my-lv`. |
||||
|
||||
These features, collectively, provide great ease in managing storage systems especially for large enterprise class systems where a large array of disks are typically used. |
||||
@ -1 +1,13 @@ |
||||
# Disks filesystems |
||||
# Linux Disks Filesystems |
||||
|
||||
Linux uses a variety of filesystems to allow us to store and retrieve data from the hardware of a computer system such as disks. The filesystem defines how data is organized, stored, and retrieved on these storage devices. Examples of popular Linux filesystems include EXT4, FAT32, NTFS, and Btrfs. |
||||
|
||||
Each filesystem has its own advantages, disadvantages, and use cases. For example, EXT4 is typically used for Linux system volumes due to its robustness and compatibility with Linux, while FAT32 may be used for removable media like USB drives for its compatibility with almost all operating systems. |
||||
|
||||
Here's an example of how to display the type of filesystems of your mounted devices with the "df" command in Linux: |
||||
|
||||
```bash |
||||
df -T |
||||
``` |
||||
|
||||
The output shows the names of your disks, their filesystem types, and other additional information such as total space, used space, and available space on the disks. |
||||
@ -1 +1,15 @@ |
||||
# Logs |
||||
# Introduction to Logs |
||||
|
||||
Linux, much like other operating systems, maintains logs to help administrators understand what is happening on the system. These logs document everything, including users' activities, system errors, and kernel messages. A particularly important time for insightful log messages is during the system boot process, when key system components are loaded and initialized. |
||||
|
||||
The "logs under booting" in Linux refers to the messages and information that are generated during the boot process. These logs record all operations and events that take place while the system is booting, which might assist in diagnosing a system issue or understanding system behavior. |
||||
|
||||
Linux utilizes various log message levels from `emerg` (the system is unusable) to `debug` (debug-level messages). During the boot process, messages from various components of the system like kernel, init, services, etc., are stored. Many Linux distributions use systemd logging system, `journalctl`, which holds the logs of the boot process. |
||||
|
||||
Viewing boot messages can occur in real-time with the `dmesg` command. It's used to read and print the kernel ring buffer. Or they can be accessed via the logging setup of your system, which often includes text files in `/var/log`. |
||||
|
||||
```shell |
||||
dmesg | less |
||||
``` |
||||
|
||||
This command presents the boot logs in a less direct format with the ability to scroll up and down. The kernel ring buffer only has a certain size, so old messages will be discarded after some time. |
||||
@ -1 +1,12 @@ |
||||
# Boot loaders |
||||
# Boot Loaders |
||||
|
||||
Boot Loaders play an integral role in booting up any Linux-based system. When the system is switched on, it's the Boot Loader that takes charge and loads the kernel of the OS into the system’s memory. The kernel then initializes the hardware components and loads necessary drivers, after which it starts the scheduler and executes the init process. |
||||
|
||||
Typically, the two most commonly used boot loaders in Linux are LILO (Linux Loader) and GRUB (GRand Unified Bootloader). GRUB sets the standard for modern day Linux booting, providing rich features like a graphical interface, scripting, and debugging capabilities. LILO, on the other hand, is older and does not have as many features, but runs on a broader range of hardware platforms. |
||||
|
||||
```bash |
||||
# This command updates the GRUB bootloader |
||||
sudo update-grub |
||||
``` |
||||
|
||||
Irrespective of the type of Boot Loader used, understanding and configuring them properly is essential for maintaining an efficient, stable and secure operating system. Boot loaders also allow users to switch between different operating systems on the same machine, if required. |
||||
@ -1 +1,18 @@ |
||||
# Booting linux |
||||
# Booting Linux |
||||
|
||||
Booting Linux refers to the process that the Linux operating system undergoes when a computer system is powered on. When you switch on your device, the system bootloader is loaded into the main memory from a fixed location to start the main operating system. |
||||
|
||||
The whole process involves several stages including POST (Power-On Self Test), MBR (Master Boot Record), GRUB (GRand Unified Bootloader), Kernel, Init process, and finally the GUI or command line interface where users interact. |
||||
|
||||
During this process, vital system checks are executed, hardware is detected, appropriate drivers are loaded, filesystems are mounted, necessary system processes are started, and finally, the user is presented with a login prompt. |
||||
|
||||
Here is an example of the GRUB configuration file `/etc/default/grub` which is used to configure the GRUB bootloader options: |
||||
|
||||
```bash |
||||
GRUB_DEFAULT=0 |
||||
GRUB_TIMEOUT=5 |
||||
GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian` |
||||
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash" |
||||
GRUB_CMDLINE_LINUX="" |
||||
``` |
||||
This is a basic introduction to booting Linux. However, the specifics may vary depending on the Linux distribution and the specific configurations of your system. |
||||
@ -1 +1,12 @@ |
||||
# Tcp ip |
||||
# TCP/IP |
||||
|
||||
The TCP/IP (Transmission Control Protocol/Internet Protocol) forms the backbone of internet protocols. Essentially, it is a set of networking protocols that allows two or more computers to communicate. In the context of Linux, TCP/IP networking is a fundamental part of the operating system's functionality. It provides a platform for establishing connections and facilitating data transfer between two endpoints. |
||||
|
||||
TCP/IP serves a vital role in enabling a host, given a correct IP configuration, to connect and interact with other hosts on the same or different networks. It is comprised of a four layers model, including the Network Interface, Internet, Transport, and Application layers. Understanding TCP/IP, its structure and how it works are crucial for effectively managing and troubleshooting Linux networks. |
||||
|
||||
Below is a basic command using TCP/IP protocol in Linux: |
||||
|
||||
```bash |
||||
# To view all active TCP/IP network connections |
||||
netstat -at |
||||
``` |
||||
@ -1 +1,15 @@ |
||||
# Subnetting |
||||
|
||||
Subnetting is a critical process in Linux networking. This practice involves dividing a network into two or more networks, known as subnets. Subnetting helps improve network performance and security. In Linux, subnetting can be managed within the context of the Internet Protocol (IP) addressing scheme, where it's crucial in organizing and managing IP addresses within a network, preventing IP conflicts and efficiently utilizing IP address ranges. This technique is invaluable in large complex Linux networking environments where IP address management can become overwhelmingly intricate. |
||||
|
||||
Generally, the following commands are used in Linux for subnetting: |
||||
|
||||
```shell |
||||
# Display current routing table |
||||
$ route -n |
||||
|
||||
# Add a new subnet |
||||
$ route add -net xxx.xxx.xxx.x/xx gw yyy.yyy.yyy.y |
||||
``` |
||||
|
||||
Please replace the `xxx.xxx.xxx.x/xx` with your desired subnet address and network mask and replace `yyy.yyy.yyy.y` with the intended default gateway for the subnet. |
||||
@ -1 +1,9 @@ |
||||
# Ethernet arp rarp |
||||
# Ethernet, ARP and RARP |
||||
|
||||
Linux serves as a prevalent OS choice for networking due to its robust, customizable, and open-source nature. Understanding networking in Linux involves comprehending various protocols and tools. Three crucial components of this landscape include Ethernet, ARP (Address Resolution Protocol), and RARP (Reverse Address Resolution Protocol). |
||||
|
||||
- Ethernet: It's the most widely installed LAN (Local Area Network) technology, allowing devices to communicate within a local area network. |
||||
- ARP: As per its name, it provides address resolution, translating IP addresses into MAC (Media Access Control) addresses, facilitating more direct network communication. |
||||
- RARP: It is the Reverse Address Resolution Protocol, working in the opposite way to ARP. It converts MAC addresses into IP addresses, which is useful in scenarios when a computer knows its MAC address but needs to find out its IP address. |
||||
|
||||
Knowledge of these components is indispensable in diagnosing and managing networking issues in Linux. |
||||
@ -1 +1,17 @@ |
||||
# Dhcp |
||||
# DHCP |
||||
|
||||
The Dynamic Host Configuration Protocol (DHCP) is a critical component of any network. In Linux networking, it is used for allocating IP addresses dynamically within a network. |
||||
|
||||
The DHCP server effectively manages the IP addresses and information related to them, making sure that each client machine gets a unique IP and all the correct network information. |
||||
|
||||
In Linux, DHCP can be configured and managed using terminal commands. This involves the installation of the DHCP server software, editing the configuration files, and managing the server's services. |
||||
|
||||
A traditional DHCP server should have a static IP address to manage the IP distribution effectively. The DHCP in Linux also handles DNS and other related data that your network might require. |
||||
|
||||
Here is an example of a basic command to install a DHCP server in a Debian-based Linux: |
||||
|
||||
```bash |
||||
sudo apt-get install isc-dhcp-server |
||||
``` |
||||
|
||||
After the installation process, all configurations of the DHCP server are done in the configuration file located at `/etc/dhcp/dhcpd.conf` which can be edited using any text editor. |
||||
@ -1 +1,13 @@ |
||||
# Ip routing |
||||
# IP Routing |
||||
|
||||
IP Routing in Linux refers to the process of setting up routing tables and configuring network routes for networking interfaces within the Linux operating system. It is the kernel’s responsibility to handle this task which involves the selection of pathways for sending network packets across to their intended destinations on a network. |
||||
|
||||
This task is carried out using various command-line tools and the networking configuration files. The principle command-line tool for network configuration in Linux used to be `ifconfig`, but it has now been mostly replaced by the `ip` command. |
||||
|
||||
For example, to view the routing table in Linux, the following command is used: |
||||
|
||||
```bash |
||||
$ ip route show |
||||
``` |
||||
|
||||
This command returns a list of all routes that are known to the kernel. |
||||
@ -1 +1,19 @@ |
||||
# Dns resolution |
||||
# DNS Resolution in Networking on Linux |
||||
|
||||
Domain Name System (DNS) is a decentralized system used for converting hostnames into IP addresses, making it easier for users to access websites without having to remember specific numeric IP addresses. DNS resolution, therefore, is a critical aspect of networking in Linux. |
||||
|
||||
On Linux systems, when an application needs to connect to a certain URL, it consults the DNS resolver. This resolver, using the file `/etc/resolv.conf`, communicates with the DNS server, which then converts the URL into an IP address to establish a network connection. |
||||
|
||||
Below command is used to query DNS and fetch IP addresses: |
||||
|
||||
```bash |
||||
nslookup www.example.com |
||||
``` |
||||
|
||||
Or using dig command: |
||||
|
||||
```bash |
||||
dig www.example.com |
||||
``` |
||||
|
||||
Getting a good understanding of the DNS resolution process provides a solid base for tasks like network troubleshooting and web server setup on a Linux system. |
||||
@ -1 +1,15 @@ |
||||
# Netfilter |
||||
|
||||
Netfilter is a powerful tool included in Linux that provides the functionality for maneuvering and altering network packets. It is essentially a framework that acts as an interface between the kernel and the packet, allowing for the manipulation and transformation of packets in transit. |
||||
|
||||
Netfilter's primary application is in developing firewall systems and managing network address translations (NATs). In Linux, netfilter is extremely valuable due to the wide range of applications it offers, from traffic control, packet modification, logging, and network intrusion detection. |
||||
|
||||
The structure of netfilter allows for custom functions, often referred to as hooks, to be inserted into the kernel's networking stack. These hooks can manipulate or inspect packets at various stages like prerouting, local in, forward, local out, and postrouting. |
||||
|
||||
A common tool used in conjunction with netfilter is iptables, which provides a mechanism to configure the tables in the kernel provided by the Netfilter Framework. |
||||
|
||||
Here is an example of using iptables with netfilter module to create a simple firewall rule: |
||||
```bash |
||||
iptables -A INPUT -i eth0 -s 192.168.0.0/24 -m netfilter --netfilter-name example --action drop |
||||
``` |
||||
In this command, '-A INPUT' is adding a new rule to the 'INPUT' chain. '-i eth0' is specifying the network interface, and '-s 192.168.0.0/24' is designating the IP address range for the rule. '-m netfilter' is calling the netfilter module, '--netfilter-name example' is naming the rule, and '--action drop' is specifying how to handle the matching packets (In this case, dropping them). |
||||
@ -1 +1,13 @@ |
||||
# Ssh |
||||
# SSH (Secure Shell) |
||||
|
||||
In the domain of Linux networking, Secure Shell (SSH) holds a vital role. SSH is a cryptographic network protocol primarily used for secure data communication, remote command-line login, remote command execution, and other secure network services between two networked computers. Emphasizing confidentiality, integrity, and security of data during transmission, SSH offers a much safer method of remote access than its non-secure counterparts, such as Telnet. |
||||
|
||||
Given its importance and widespread usage, a solid understanding of its functionality is essential for anyone looking to navigate Linux operating systems and manage networks efficiently. |
||||
|
||||
Here is an example of using SSH to connect from your local machine to a remote server: |
||||
|
||||
```bash |
||||
ssh username@server_ip_address |
||||
``` |
||||
|
||||
In the above command, 'username' represents the remote user account name and 'server_ip_address' is the IP address of the remote server you are trying to access. Once you've entered this command, you'll be prompted to enter the password for the specified user's account. After successful verification, you'll be logged into the remote Linux server. |
||||
@ -1 +1,13 @@ |
||||
# File transfer |
||||
# Linux File Transfer under Networking |
||||
|
||||
In Linux, file transfer is an act of copying or moving a file from one computer to another over a network connection. This concept is essential for system administrators and end-users who require the ability to share files between systems or networks. |
||||
|
||||
Linux provides several command-line tools and applications for network-based file transfers. These tools support various standard protocols such as FTP, HTTP, SCP, SFTP, and NFS. Some of the most well-known commands for file transfer include `scp`, `rsync`, and `wget`. |
||||
|
||||
For instance, when transferring a file from a local machine to a remote server, the `scp` command can be utilized as follows: |
||||
```bash |
||||
scp /path/to/local/file username@remote:/path/to/destination |
||||
``` |
||||
This command would copy the file to the designated remote system. |
||||
|
||||
Understanding and efficiently using these tools can make the task of file sharing over networks streamlined, easier, and more secure. |
||||
@ -1 +1,13 @@ |
||||
# Networking |
||||
|
||||
Networking is a crucial aspect in the Linux environment. It enables Linux systems to connect, interact, and share resources with other systems, be it Linux, Windows, macOS or any other operating system. Linux provides a wealth of tools and commands to manage network interfaces, view their configuration details, troubleshoot issues and automate tasks, demonstrating its robustness and versatility. The Linux networking stack is well-regarded for its performance, its ability to run large-scale and exhaustive configurations, and its support for a wide variety of network protocols. |
||||
|
||||
Linux adopts a file-based approach for network configuration, storing network-related settings and configurations in standard files, such as /etc/network/interfaces or /etc/sysconfig/network-scripts/, depending on the Linux distribution. |
||||
|
||||
Perhaps one of the most popular commands related to networking on a Linux system is the `ifconfig` command: |
||||
|
||||
```bash |
||||
ifconfig |
||||
``` |
||||
|
||||
This will output information about all network interfaces currently active on the system. However, please note that `ifconfig` is becoming obsolete and being replaced by `ip`, which offers more features and capabilities. |
||||
|
||||
@ -1 +1,13 @@ |
||||
# Backup tools |
||||
# Linux Backup Tools |
||||
|
||||
In the world of Linux, there are a wide array of utilities and tools available for creating and managing backups of your important data. Backups are crucial to ensure the preservation and safety of data in the event of hardware failure, accidental deletion, or data corruption. Therefore, understanding how to leverage Linux backup tools is an essential skill for any system administrator or user. |
||||
|
||||
Some of the popular and powerful backup tools in Linux include `rsync`, `tar`, `dump`, `restore`, and various GUI based tools such as `Deja Dup` and `Back In Time`. These tools provide various features such as incremental backups, automation, scheduling, and encryption support. |
||||
|
||||
For instance, a basic usage of `rsync` can be shown below: |
||||
|
||||
```bash |
||||
rsync -avz /source/directory/ /destination/directory |
||||
``` |
||||
|
||||
This command would create a backup by synchronizing the source directory with the destination directory. The options are as follows: `-a` (archive mode), `-v` (verbose), and `-z` (compress data). |
||||
@ -1 +1,19 @@ |
||||
# Debugging |
||||
# Debugging in Shell Programming Under Linux |
||||
|
||||
Linux is a robust and flexible operating system that many developers and systems administrators prefer for its versatility and power. In particular, shell programming in Linux allows you to automate tasks and manage systems with high efficiency. However, given the intricate nature of shell scripts, debugging is an essential skill to handle errors and improve code performance. |
||||
|
||||
When encountering an issue in a shell script, you have several debugging tools at your disposal in a Linux environment. These aid in detecting, tracing, and fixing errors or bugs in your shell scripts. Some of these debugging tools include the bash shell's `-x` (or `-v`) options, which allow for execution traces. Other tools like `trap`, `set` command, or even leveraging external debugging tools such as `shellcheck` can also be highly effective. |
||||
|
||||
Consider opening your shell script with the -x option for execution tracing, like so: |
||||
|
||||
```bash |
||||
#!/bin/bash -x |
||||
``` |
||||
|
||||
Or, you can run a script in debug mode directly from the command line. |
||||
|
||||
```bash |
||||
bash -x script.sh |
||||
``` |
||||
|
||||
These debugging tools and options can drastically help you in making your scripts more error-proof and efficient. |
||||
@ -1 +1,25 @@ |
||||
# Conditionals |
||||
# Conditionals in Shell Programming |
||||
|
||||
Conditional statements in Linux Shell Programming allow scripts to make decisions based on conditions. These are integral part of any programming language and just like other languages such as C, Python, JavaScript, Linux Shell also provides conditional statements. A conditional statement can be defined as an integral part of the shell script which guides the interpreter into the correct path of execution depending on the given conditions. |
||||
|
||||
In shell, the main commands that are used for conditionals statements are `if`, `elif` (else if), and `else`. These commands are used for process control based on the results of conditional tests which can evaluate the value of string variables, arithmetic tests, or the status of a process. |
||||
|
||||
Here's a simple illustration of how they work: |
||||
|
||||
```bash |
||||
#!/bin/sh |
||||
a=10 |
||||
b=20 |
||||
|
||||
if [ $a -lt 20 ] |
||||
then |
||||
echo "a is less than b" |
||||
elif [ $a -gt 20 ] |
||||
then |
||||
echo "a is greater than b" |
||||
else |
||||
echo "a is equal to b" |
||||
fi |
||||
``` |
||||
|
||||
In the above script, the condition inside the `if` statement is being checked. If the condition is `true`, then the code block inside the `if` statement gets executed, otherwise, it moves to the `elif` condition and so on. If none of those conditions is satisfied, then the code block inside the `else` statement will be executed. |
||||
@ -1 +1,26 @@ |
||||
# Loops |
||||
|
||||
Loops in shell programming are a fundamental concept that allows a certain block of code to be executed over and over again based on a given condition. They are crucial for automating repetitive tasks, thus making the coding process more efficient and less error-prone. |
||||
|
||||
In Linux, shell scripts commonly use three types of loops - for, while, and until. |
||||
|
||||
- `for` loop iterates over a list of items and performs actions on each of them. |
||||
- `while` loop executes commands as long as the control condition remains true. |
||||
- `until` loop runs commands until the control condition becomes true. |
||||
|
||||
Here is a simple sample for loop in bash/shell: |
||||
|
||||
```bash |
||||
for i in 1 2 3 |
||||
do |
||||
echo $i |
||||
done |
||||
``` |
||||
This will output: |
||||
``` |
||||
1 |
||||
2 |
||||
3 |
||||
``` |
||||
|
||||
This is just the surface of looping in shell programming in Linux. These structures, when used wisely, can enhance your scripts and open up many areas for effective scripting and automation. |
||||
@ -1 +1,25 @@ |
||||
# Literals |
||||
# Literals in Shell Programming on Linux |
||||
|
||||
In a Linux environment, shell scripting is an essential part of system operation and application development. One key aspect of shell scripting is the use of literals. The term 'literal', in computer science and shell programming, refers to a notation for representing a fixed value in source code. In shell scripts, these fixed values can include string literals, numeric literals or a boolean. When reading and understanding existing scripts or writing new ones, it's crucial to understand how and when to use these literals. Some basic shell script literals under Linux are listed below: |
||||
|
||||
String Literals: They can be defined by enclosing the text between either single or double quotes. For instance, 'Hello, world!' or "Hello, world!". |
||||
|
||||
Numeric Literals: They represent a sequence of digits. For example, 25, 100, or 1234. |
||||
|
||||
Boolean Literals: In most of the Linux shell scripts, 0 represents true, and 1 represents false. |
||||
|
||||
Be mindful of the type of literal you're using as it can significantly influence your scripting, your code's readability, and its overall functionality. |
||||
|
||||
```bash |
||||
#!/bin/bash |
||||
# Example of literals in shell script |
||||
|
||||
StringLiteral="This is a string literal" |
||||
NumericLiteral=125 |
||||
echo $StringLiteral |
||||
echo $NumericLiteral |
||||
``` |
||||
|
||||
In this example, `StringLiteral` and `NumericLiteral` are literals and `echo` is used to print them. |
||||
|
||||
Always remember, a good understanding of literals is fundamental when it comes to shell scripting in Linux. |
||||
@ -1 +1,15 @@ |
||||
# Variables |
||||
# Variables in Shell Programming on Linux |
||||
|
||||
In the context of Shell Programming on Linux, a variable is a character string that can store system data or user-defined data. It is a symbolic name that is assigned to an amount of storage space that can change its value during the execution of the program. Variables play a vital role in any programming paradigm, and shell scripting is no different. |
||||
|
||||
Variables fall into two broad categories: **System Variables** and **User-Defined Variables**. System variables are created and maintained by the Linux system itself. Examples include PATH, HOME, and PWD. User-defined variables, on the other hand, are created and controlled by the user. |
||||
|
||||
A variable in shell scripting is defined by the '=' (equals) operator, and the value can be retrieved by prefixing the variable name with a '$' (dollar) sign. |
||||
|
||||
```bash |
||||
# Create a User-Defined Variable |
||||
MY_VARIABLE="Hello World" |
||||
|
||||
# Print the value of the Variable |
||||
echo $MY_VARIABLE # Output: Hello World |
||||
``` |
||||
@ -1 +1,14 @@ |
||||
# Shell programming |
||||
# Shell Programming |
||||
|
||||
Shell programming, also known as shell scripting, is an integral part of the Linux operating system. A shell script is essentially a program that the system's shell executes. While it may not be as powerful as compiled languages like C or C++, shell programming is quite potent for administrative-level tasks, automating repetitive tasks, and system monitoring. |
||||
|
||||
Most Linux distributions come with bash (Bourne Again Shell) as the default shell which is not only an excellent command-line shell, but also an outstanding scripting language. Shell scripts are generally written in a text editor and then can be run directly from the Linux command line. |
||||
|
||||
A simple example of a bash shell script: |
||||
|
||||
```bash |
||||
#!/bin/bash |
||||
# My first script |
||||
echo "Hello, World!" |
||||
``` |
||||
The 'echo' command prints its argument, in this case "Hello, World!", to the terminal. |
||||
@ -1 +1,12 @@ |
||||
# Icmp |
||||
# ICMP |
||||
|
||||
Internet Control Message Protocol (ICMP) is a supportive protocol used primarily by network devices to communicate updates or error information to other devices. When troubleshooting network issues in a Linux environment, ICMP forms a crucial aspect. It can be utilized to send error messages indicating, for example, that a requested service is not available or that a host or router could not be reached. ICMP can also be used to relay query messages. |
||||
|
||||
In Linux systems, common command-line tools related to ICMP include `ping` and `traceroute`, both used to diagnose the state of the network and often part of troubleshooting efforts. |
||||
|
||||
```bash |
||||
# Use of ICMP via the ping command to send an echo request to a specific host |
||||
ping www.google.com |
||||
``` |
||||
|
||||
This simple yet effective tool should not be missed out in any Linux network troubleshooting arsenal. |
||||
@ -1 +1,8 @@ |
||||
# Ping |
||||
|
||||
`Ping` is a critical tool when it comes to network troubleshooting on Linux operating systems. The `ping` command allows you to check the connectivity status between your host and a target machine, which could be another computer, server or any device on a network. This diagnostic tool sends ICMP (Internet Control Message Protocol) ECHO_REQUEST packets to the target host and listens for ECHO_RESPONSE returns, giving insight into the health and speed of the connection. |
||||
|
||||
```bash |
||||
ping <target IP or hostname> |
||||
``` |
||||
If there is any issue reaching the target host, `ping` can identify this and provide feedback, making it an essential component in troubleshooting network issues. In many cases, it is the first tool a Linux user will turn to when diagnosing network connectivity problems. |
||||
@ -1 +1,10 @@ |
||||
# Traceroute |
||||
|
||||
Traceroute is a network diagnostic tool used widely in Linux systems for troubleshooting. It is designed to display the path that packets take from the system where traceroute is run to a specified destination system or website. It's used to identify routing problems, offer latency measurement, and figure out the network structure as packets journey across the internet. |
||||
|
||||
Each jump along the route is tested multiple times (the default is 3 but this can be changed), and the round-trip time for each packet is displayed. If certain packets are failing to reach their destination, traceroute can help diagnose where the failure is occurring. |
||||
|
||||
Tracing route in Linux can be achieved by executing the `traceroute` command which allows you to discover the routes that internet protocol packets follow when traveling to their destination. |
||||
```bash |
||||
$ traceroute www.example.com |
||||
``` |
||||
@ -1 +1,12 @@ |
||||
# Netstat |
||||
|
||||
Netstat, short for network statistics, is a built-in command-line tool used in Linux systems for network troubleshooting and performance measurement. It provides statistics for protocols, a list of open ports, routing table information, and other important network details. Administrators and developers work with netstat to examine network issues and understand how a system communicates with others. |
||||
|
||||
Its functionality is extended owing to various command-line options it supports, which could be used singularly or combinedly to fine-tune the output. These might include displaying numerical addresses instead of names (`-n`), continuous monitoring (`-c`), or spotting connections on a specific protocol (`-t`, `-u`). |
||||
|
||||
Here is a brief snippet of how netstat may typically be used: |
||||
|
||||
```bash |
||||
# List all connections with numerical values. |
||||
netstat -n |
||||
``` |
||||
@ -1 +1,13 @@ |
||||
# Packet analysis |
||||
# Packet Analysis |
||||
|
||||
In the realm of Linux system administration and network troubleshooting, packet analysis is a key skill. It involves the use of tools and techniques to capture and analyze network traffic. By inspecting the data being sent and received over a network, system and network administrators can identify and troubleshoot issues such as poor performance, connectivity problems, and security vulnerabilities. |
||||
|
||||
Tools like tcpdump and Wireshark are common utilities for this very purpose. They display packet-level details to provide a complete picture of network activities. These are particularly useful for network diagnostics and debugging issues related to network protocols. |
||||
|
||||
A basic example of using tcpdump to capture packets in a Linux system command might look like this: |
||||
|
||||
```sh |
||||
sudo tcpdump -i eth0 |
||||
``` |
||||
|
||||
This command captures and displays packets being transmitted or received over the `eth0` network interface. |
||||
@ -1 +1,11 @@ |
||||
# Troubleshooting |
||||
|
||||
Troubleshooting is an essential skill for any Linux user or administrator. This involves identifying and resolving problems or issues within a Linux system. These problems can range from common system errors, hardware or software issues, network connectivity problems, to management of system resources. The process of troubleshooting in Linux often involves the use of command-line tools, inspecting system and application log files, understanding system processes, and sometimes, deep diving into the Linux kernel. |
||||
|
||||
The key to effective troubleshooting is understanding how Linux works and being familiar with the common command-line tools. Also, being able to interpret error messages, use Linux's built-in debugging tools, and understand common problem symptoms can speed up resolution time. |
||||
|
||||
```bash |
||||
# example of using a command-line tool for troubleshooting |
||||
top |
||||
``` |
||||
The `top` command is a commonly used troubleshooting tool that provides a dynamic, real-time view of the processes running on a system. It can be particularly useful for identifying resource-heavy processes that could be causing performance issues. |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue