Add Files

contents/01- Understand and use essential tools/01- Access a shell prompt and issue commands with correct syntax.md

@@ -0,0 +1,162 @@
+## 01- Access a shell prompt and issue commands with correct syntax:
+
+The topic **"Access a shell prompt and issue commands with correct syntax"** is foundational to the RHCSA (Red Hat Certified System Administrator) exam and is likely the first step in most exam tasks. This objective tests your ability to interact with the shell effectively, execute commands correctly, and use basic Linux command-line tools. Let's break down what this might involve at an RHCSA exam level and what you need to know to be successful.
+
+### 1. **Accessing the Shell Prompt**
+You need to know how to:
+- Log in to a Linux system (either locally or remotely via SSH).
+- Open and use a terminal emulator (like GNOME Terminal in GUI mode or `tty` in a text mode environment).
+
+**Example:**  
+- **Task:** Log in to the system via SSH as the user `examuser`.
+
+  **Command:**
+  ```bash
+  ssh examuser@hostname
+  ```
+
+  This will connect you to the system `hostname` as the user `examuser`.
+
+### 2. **Using the Bash Shell**
+Bash (Bourne Again Shell) is the default shell on Red Hat-based systems, and you are expected to be proficient in using it. You should know how to:
+- Issue basic commands.
+- Correctly use command syntax (including options and arguments).
+- Use relative and absolute paths.
+
+#### **Example: Navigating the Filesystem**
+- **Task:** Change the current working directory to `/var/log` and list all files, including hidden files.
+
+  **Command:**
+  ```bash
+  cd /var/log
+  ls -a
+  ```
+
+  This command changes the working directory and lists all files (including hidden files denoted by a `.` at the beginning of the filename).
+
+#### **Example: Creating and Removing Files/Directories**
+- **Task:** Create a directory named `testdir` in your home directory, and then remove it.
+
+  **Commands:**
+  ```bash
+  mkdir ~/testdir
+  rmdir ~/testdir
+  ```
+
+  `mkdir` creates the directory, and `rmdir` removes it (only works if the directory is empty).
+
+### 3. **Understanding Command Syntax**
+A big part of this objective is being able to understand and apply correct command syntax. This includes:
+- Command structure: `command [option(s)] [argument(s)]`
+- Knowing the difference between options (typically prefixed by `-` or `--`) and arguments (which are file names, paths, or other inputs).
+
+#### **Example: Listing Files with Detailed Information**
+- **Task:** List all files in `/etc` with detailed information (permissions, owner, size, etc.).
+
+  **Command:**
+  ```bash
+  ls -l /etc
+  ```
+
+  Here, `-l` is the option (long format), and `/etc` is the argument (the directory to list).
+
+### 4. **Using Basic File Manipulation Commands**
+Some essential file commands you should know:
+- **`cat`**: Display file content.
+- **`cp`**: Copy files and directories.
+- **`mv`**: Move or rename files and directories.
+- **`rm`**: Remove files and directories.
+
+#### **Example: Copying and Renaming a File**
+- **Task:** Copy the file `/etc/hosts` to your home directory and rename it `myhosts`.
+
+  **Command:**
+  ```bash
+  cp /etc/hosts ~/myhosts
+  ```
+
+  This copies the file from `/etc` to your home directory and renames it.
+
+### 5. **Using Wildcards and Special Characters**
+Knowing how to use wildcards (`*`, `?`, `[]`) and special characters (like `|`, `>`, `&`, `;`) is crucial for working efficiently in the shell.
+
+#### **Example: Using Wildcards**
+- **Task:** List all files in `/var/log` that start with the letter `m`.
+
+  **Command:**
+  ```bash
+  ls /var/log/m*
+  ```
+
+  The `*` wildcard matches any number of characters.
+
+#### **Example: Redirecting Output**
+- **Task:** Append the output of the `ls` command for `/var/log` to a file called `logfiles.txt`.
+
+  **Command:**
+  ```bash
+  ls /var/log >> logfiles.txt
+  ```
+
+  Here, `>>` appends the output of the command to the file.
+
+### 6. **Running Commands as Root (Using `sudo`)**
+In many cases, you will need to run commands with root privileges. Using `sudo` allows a permitted user to execute a command as the superuser.
+
+#### **Example: Installing a Package**
+- **Task:** Install the package `httpd` on the system.
+
+  **Command:**
+  ```bash
+  sudo yum install httpd
+  ```
+
+  `sudo` runs the `yum install httpd` command as the root user.
+
+### 7. **Viewing and Editing Files**
+You must be comfortable with viewing, creating, and editing text files using commands like `cat`, `less`, and text editors such as `vim` or `nano`.
+
+#### **Example: Viewing a File**
+- **Task:** View the contents of `/etc/passwd`.
+
+  **Command:**
+  ```bash
+  cat /etc/passwd
+  ```
+
+  This will display the contents of the `passwd` file.
+
+#### **Example: Editing a File**
+- **Task:** Open the file `/etc/hosts` in the `vim` editor and add an entry for a host named `test.local` with the IP `192.168.1.10`.
+
+  **Commands:**
+  ```bash
+  sudo vim /etc/hosts
+  ```
+  - Inside `vim`, press `i` to enter insert mode.
+  - Add the following line:
+    ```
+    192.168.1.10 test.local
+    ```
+  - Press `Esc`, then type `:wq` to save and exit.
+
+### 8. **Using Command History and Autocompletion**
+The Bash shell provides tools like command history (`history`, `!!`, `!<number>`) and autocompletion (using the `Tab` key) to speed up your workflow.
+
+#### **Example: Re-running the Last Command**
+- **Task:** Re-run the last command you executed.
+
+  **Command:**
+  ```bash
+  !!
+  ```
+
+  `!!` recalls and executes the last command.
+
+### Summary of Key Skills:
+- **Access the shell:** Know how to log in to a system using SSH or at the console.
+- **Run basic commands:** Navigate the filesystem, manage files, and understand command syntax.
+- **Use special characters:** Wildcards, redirection, and pipes are critical to working efficiently.
+- **Run commands as root:** Be familiar with `sudo` for privileged tasks.
+- **View and edit files:** You must know how to view file contents and make necessary edits.
+- **Command history and completion:** Know how to leverage these features for efficiency

contents/01- Understand and use essential tools/02- Use input-output redirection.md

@@ -0,0 +1,165 @@
+## 02- Use input-output redirection:
+
+The topic **"Use input-output redirection (>, >>, |, 2>, etc.)"** is an essential skill for Linux command-line proficiency, and mastering it is necessary for the RHCSA exam. It involves directing the output of commands to files, sending input from files or other commands, and handling errors effectively. Below is an explanation of what you need to know at the RHCSA level and examples of how these redirections work, aligned with the exam requirements.
+
+
+### **1. Standard Output Redirection (`>`, `>>`)**
+Redirection of standard output is one of the most fundamental aspects of shell redirection.
+
+- `>` redirects the output of a command to a file, overwriting the file if it exists.
+- `>>` appends the output of a command to a file, preserving existing content.
+
+#### **Example 1: Overwriting a File**
+- **Task:** Redirect the output of the `ls /etc` command to a file named `output.txt` in your home directory, overwriting any existing content.
+
+  **Command:**
+  ```bash
+  ls /etc > ~/output.txt
+  ```
+
+  This will list the contents of `/etc` and store the result in `output.txt`. If the file already exists, its contents will be overwritten.
+
+#### **Example 2: Appending to a File**
+- **Task:** Append the output of the `date` command (which prints the current date and time) to `output.txt`.
+
+  **Command:**
+  ```bash
+  date >> ~/output.txt
+  ```
+
+  This appends the current date and time to `output.txt` without overwriting its existing content.
+
+### **2. Standard Input Redirection (`<`)**
+Redirection of standard input is less commonly used but essential for certain tasks where you want to read input from a file rather than typing it in manually.
+
+#### **Example 3: Using Input Redirection**
+- **Task:** Use the `cat` command to display the contents of a file `myfile.txt` using input redirection.
+
+  **Command:**
+  ```bash
+  cat < myfile.txt
+  ```
+
+  This command tells `cat` to read the input from `myfile.txt` rather than waiting for input from the keyboard.
+
+### **3. Piping Output Between Commands (`|`)**
+Piping allows you to use the output of one command as the input for another. This is extremely powerful for chaining commands together to perform complex tasks.
+
+#### **Example 4: Piping Output to Another Command**
+- **Task:** List all files in `/var/log`, but only display the first 10 lines of the output.
+
+  **Command:**
+  ```bash
+  ls /var/log | head -n 10
+  ```
+
+  Here, the output of `ls /var/log` is piped to the `head` command, which limits the output to the first 10 lines.
+
+#### **Example 5: Combining Piping and Redirection**
+- **Task:** Count the number of files in `/etc` and redirect the result to `count.txt`.
+
+  **Command:**
+  ```bash
+  ls /etc | wc -l > ~/count.txt
+  ```
+
+  This pipes the output of `ls /etc` (list files in `/etc`) to `wc -l`, which counts the lines (i.e., the number of files), and redirects that result to `count.txt`.
+
+### **4. Error Redirection (`2>`, `2>>`)**
+By default, commands send error messages to the standard error (stderr), which is separate from the standard output (stdout). You can redirect errors to a file using `2>`, which refers to file descriptor 2 (stderr).
+
+- `2>` redirects error messages to a file, overwriting it.
+- `2>>` appends error messages to a file, preserving existing content.
+
+#### **Example 6: Redirecting Errors**
+- **Task:** Redirect the errors from an invalid `ls` command to a file named `errors.txt`.
+
+  **Command:**
+  ```bash
+  ls /invalid/directory 2> ~/errors.txt
+  ```
+
+  This command tries to list a non-existent directory, and any errors will be saved to `errors.txt`.
+
+#### **Example 7: Appending Errors**
+- **Task:** Append any errors generated by a command to `errors.txt`.
+
+  **Command:**
+  ```bash
+  ls /another/invalid/directory 2>> ~/errors.txt
+  ```
+
+  Here, errors generated by the command are appended to `errors.txt` instead of overwriting it.
+
+### **5. Redirecting Both Output and Error**
+You can redirect both stdout and stderr to the same file using `&>`. This ensures that both regular output and errors are captured in one place.
+
+#### **Example 8: Redirecting Both Output and Error**
+- **Task:** Run a command that lists a directory, and send both the output and errors to `combined.txt`.
+
+  **Command:**
+  ```bash
+  ls /var/log /invalid/directory &> ~/combined.txt
+  ```
+
+  In this example, the output of `ls /var/log` and any errors from `/invalid/directory` are redirected to `combined.txt`.
+
+### **6. Suppressing Output (`/dev/null`)**
+You can discard unwanted output by redirecting it to `/dev/null`, a special file that acts as a "black hole" for output.
+
+#### **Example 9: Discarding Standard Output**
+- **Task:** Run a command that produces output, but discard that output.
+
+  **Command:**
+  ```bash
+  ls /etc > /dev/null
+  ```
+
+  This command runs `ls /etc`, but discards the output by redirecting it to `/dev/null`.
+
+#### **Example 10: Discarding Errors**
+- **Task:** Run a command that produces errors, but discard those errors.
+
+  **Command:**
+  ```bash
+  ls /invalid/directory 2> /dev/null
+  ```
+
+  Any errors generated by this command are discarded by sending them to `/dev/null`.
+
+### **7. Redirecting Output and Errors Separately**
+You can also redirect stdout and stderr to separate files.
+
+#### **Example 11: Redirecting Output and Errors to Different Files**
+- **Task:** List a valid and an invalid directory, sending output to `out.txt` and errors to `err.txt`.
+
+  **Command:**
+  ```bash
+  ls /valid/directory /invalid/directory > ~/out.txt 2> ~/err.txt
+  ```
+
+  This command lists files in `/valid/directory` and `/invalid/directory`, sending the valid output to `out.txt` and any errors to `err.txt`.
+
+### **8. Combining Multiple Redirections**
+You can chain multiple redirection and piping techniques to achieve complex results.
+
+#### **Example 12: Redirecting Both Output and Errors, and Appending**
+- **Task:** Run a command, redirect both output and errors to separate files, and append the results to those files.
+
+  **Command:**
+  ```bash
+  ls /var/log /invalid/directory >> ~/out.txt 2>> ~/err.txt
+  ```
+
+  Here, output is appended to `out.txt`, and errors are appended to `err.txt`.
+
+---
+
+### **Summary of Key Redirection Skills for RHCSA Exam**
+To summarize, you must be proficient in using the following:
+- **Standard output redirection (`>` and `>>`)** for writing and appending command output to files.
+- **Standard input redirection (`<`)** for reading input from a file.
+- **Piping (`|`)** to send output from one command as input to another command.
+- **Error redirection (`2>`, `2>>`)** to handle and redirect error messages.
+- **Suppressing output** by redirecting to `/dev/null`.
+- **Combining output and error redirection** to separate or combine stdout and stderr.