linux_temp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/LINUX-LOGO.png\" alt=\"drawing\" width=\"300\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## History"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 1950's computer evolution  \n",
    "- 1964 MIT, GE and Bell Labs developed MULTICS (Multiplexed Information Computing Service)  \n",
    "- Unics was developed at MIT (Bell Labs and GE) in the mid 60s and was published in 1970 \n",
    "- First written in Assembly language then was rewritten in C (Dennis Ritchie) in 1973  \n",
    "- In 1974 AT&T licensed UNIX for educational purposes  \n",
    "- In 1982 AT&T started selling UNIX (v7.0) and it was no longer free  \n",
    "- In 1983 Richard Stallman announced the GNU project  \n",
    "- In 1985 Stallman founded the Free Software Foundation  \n",
    "- In 1987 Andrew Tanenbaum developed MINIX based on UNIX 7 microkernel  \n",
    "- in 1991 Linus Torvalds released Linux Kernel as free software under GNU GPL  \n",
    "- GNU and Free Software Foundation added other free tools to the kernel   \n",
    "- The earliest distributions were Yggdrasil and Slackware  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Ken and Dennis](./images/Ken_Thompson_and_Dennis_Ritchie--1973.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Linus](./images/linus-torvads.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[History of Linux](https://en.wikipedia.org/wiki/History_of_Linux)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Linux Distros](https://en.wikipedia.org/wiki/Linux_distribution)**  \n",
    "**[distrowatch.com](https://distrowatch.com/)**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Red Hat Enterprise](https://developers.redhat.com/products/rhel/overview)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[CentOS Linux](https://www.centos.org/download/)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Ubuntu](https://ubuntu.com/)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`echo`    - display a line of text  \n",
    "`whoami`  - print effective userid  \n",
    "`ls`      - list directory contents  \n",
    "`cd`      - change the working directory  \n",
    "`pwd`     - print name of current/working directory  \n",
    "`mkdir`   - make directories  \n",
    "`touch`   - change file timestamps  \n",
    "`ip a`    - show / manipulate routing, devices, policy routing and tunnels  \n",
    "`cat`     - concatenate files and print on the standard output  \n",
    "`wc`      - counts words, lines, bytes, etc from text files  \n",
    "`history` - GNU History Library  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Where are these commands**  \n",
    "`$ type -a ls`  \n",
    "`$ type -a cd`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[The Linux command line for beginners](https://ubuntu.com/tutorials/command-line-for-beginners#1-overview)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using `nano` Editor**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[nano Cheatsheet](https://www.nano-editor.org/dist/latest/cheatsheet.html)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `nano <filename>` -- opens filename in editor  \n",
    "- `nano -v <filename>`  -- opens filename in view only mode  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Nano](https://help.ubuntu.com/community/Nano)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# Working with the Linux Shell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shell vs Terminal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `shell` is a program that functions as a user interface and command-line interpreter when using a command-line interface."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Parent and Child Processes**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Shell and subshell](./images/shell.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `$ ps`  -- shows currently running processes  \n",
    "- `$ sh`  -- opens a sh shell  \n",
    "- `$ ps`  -- shows currently running processes  \n",
    "- `$ bash`  -- opens a bash shell  \n",
    "- `$ ps`  -- shows currently running processes  \n",
    "- `$ exit` -- exits the current shell process  \n",
    "- `$ ps`  -- shows currently running processes  \n",
    "- etc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managing Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shell variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A shell variable only exists in the memory space of the shell in which it was created. This means that when a shell variable is created within a parent process, the variable is available in that process but **not** in any child process."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ <variable>=<value>`  \n",
    "`$ var01=test`   \n",
    "`$ var02='this is a \\n multiline variable'`   \n",
    "`$ echo $var01`    \n",
    "`$ echo ${var01}`  -- another way to print the value    \n",
    "`$ echo $var02`    \n",
    "`$ echo -e $var02`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Setting variables to command results**  \n",
    "`<variable>=$(<command>)`  \n",
    "`$ hname=$(hostname)`  \n",
    "`$ echo $hname`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`var1=$[1 + 2]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`echo $var1`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ echo $PATH`   \n",
    "`$ echo PATH = $PATH` --  Append the output of string 'PATH =' with the value of the variable PATH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ set`  -- show env vars  and shell variables\n",
    "`$ env`  -- show env vars  \n",
    "`$ compgen -v`  \n",
    "`$ export`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike shell variables, environment variables are visible to child processes. For example, the EDITOR variable contains the name of the system editor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Setting Environment Variables**  \n",
    "`$ echo $MYVAR1`  -- empty for now  \n",
    "`$ MYVAR1=myvalue1` -- setting the value of a shell variable  \n",
    "`$ MYVAR2=myvalue2`  -- setting the value of another shell variable  \n",
    "`$ export MYVAR2`  -- making a shell variable an environment variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Testing both shell and env variables**  \n",
    "`$ echo $MYVAR1` -- show myvalue1  \n",
    "`$ echo $MYVAR2` -- show myvalue2  \n",
    "`$ bash`  -- starting a subshell  \n",
    "`$ echo $MYVAR1` -- show nothing as MYVAR1 is a shell variable not visible from any subshell   \n",
    "`$ echo $MYVAR2` -- show myvalue2 as MYVAR2 is an environment variable visible from any subshell  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using `declare`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ declare -i num1`  \n",
    "`$ declare -i num2`  \n",
    "`$ num1=5`  \n",
    "`$ num2=$num1*4`  \n",
    "`$ echo $num2`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ declare -x`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ declare -a fullname=(Ahmed Sami Ali)`  \n",
    "`$ echo ${fullname[2]}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ fullname=(Ahmed Sami Ali)`  \n",
    "`$ echo ${fullname[2]}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Important Environment Variables"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "+-----------------------+-------------------------------------------------+\n",
    "| Environment Variables | Description                                     |\n",
    "|-----------------------+-------------------------------------------------|\n",
    "| $USER                 | Gives the name of the logged in user.           |\n",
    "| $PATH                 | Gives search path for commands.                 |\n",
    "| $HOME                 | Gives path of home directory.                   |\n",
    "| $PWD                  | Gives the path of present working directory.    |\n",
    "| $HOSTNAME             | Gives name of the host.                         |\n",
    "| $LANG                 | Gives the default system language.              |\n",
    "| $EDITOR               | Gives default file editor.                      |\n",
    "| $UID                  | Gives user ID of current user.                  |\n",
    "| $SHELL                | Gives location of current user’s shell program. |\n",
    "+-----------------------+-------------------------------------------------+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Test some of them**  \n",
    "`$ echo $SHELL`  \n",
    "`$ cat $HOME/.bashrc`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The special shell variable**  \n",
    "`$?` contains the exit status of the last command executed.  \n",
    "`$1`, `$2`, `$3`, ... are the positional parameters passed to the script.  \n",
    "`$0` is the name of the script/shell itself.  \n",
    "`$#` is the number of arguments passed to the script.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "$ true  # simulates exit code 0 i.e. no errors\n",
    "$ echo $?\n",
    "$ false  # simulates exit code 1 i.e. error\n",
    "$ echo $?\n",
    "```"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "some common linux exit codes\n",
    "+    0: success\n",
    "+    1: general error\n",
    "+    2: misuse of shell builtins\n",
    "+    126: command invoked cannot execute\n",
    "+    127: command not found\n",
    "+    128: invalid argument to exit\n",
    "+    128+n: fatal error signal n\n",
    "+    130: script terminated by ctrl-c\n",
    "+    255: exit status out of range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Environment Variables](https://help.ubuntu.com/community/EnvironmentVariables)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`var1=$[1+2]`  \n",
    "`echo $((1+3))`  \n",
    "`echo $[1+4]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`expr`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ expr 1 = 2`  \n",
    "`$ expr 5 \\> 4`  \n",
    "`$ expr  9 \\* 8`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`bc`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Login vs Non-Login Shell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A login shell is the shell used to authenticate the user**  \n",
    "When you login to a console linux (with no GUI) you will have to authenticate through the shell before you can start executing commands.  \n",
    "Using SSH is another example.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A non-login shell is the shell a user invokes without a login process**  \n",
    "An example is when a user opens a terminal emulator after logging on to a linux desktop.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Check the type of shell**  \n",
    "The name and the type of the shell are stored in an environment variable called 0  \n",
    "`echo $0`  \n",
    "OUTPUT: `-bash` -- the hyphen before the 'bash' means that this is a login shell.  \n",
    "OUTPUT: `bash` -- means that this is a non-login shell.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shell Startup Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many startup files you can use to prestage envrionment variables, config items, etc.  \n",
    "Two main examples are:  \n",
    "- `/etc/profile` -- used for login shells only   \n",
    "- `~/.bashrc` -- used for both login and non-login shells  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Examples of startup file usage**  \n",
    "- Edit the `/etc/profile` and add the following line at the end of the file:  \n",
    "`echo \"*** Sourcing /etc/profile ***\"`\n",
    "- Open a new terminal window  \n",
    "- Notice that the line was not shown, hence /etc/profile file was NOT sourced as this is a non-login shell  \n",
    "- run the following command `$ ssh sami@localhost` and provide your password  \n",
    "- Notice that now you can see the line \"\\*** Sourcing /etc/profile \\***\" which means that /etc/profile was sourced as this is a login shell  \n",
    "- To double check that this is a login shell run the command `$ echo $0` and validate the `-bash` output  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now edit the `~/.bashrc` file and add the following line to the end of the file:  \n",
    "`echo \"*** Sourcing $(HOME)/.bashrc ***\"`  \n",
    "- Close the terminal window and open a new one.\n",
    "- Now you should be able to see both lines coming from `/etc/profile` and `~/.bashrc` files  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `source` Command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Used to execute the commands in the configuration files and load them to memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ . <filename>`  \n",
    "`$ source <filename>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Redirection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![streams](./images/std.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Redirection permits a user to alter from the defaults for stdin, stdout, or stderr to a device or file using their file descriptors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### File Descriptor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A file descriptor is a reference, or handle, used by the kernel to access a file. A file descriptor table is created for every process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Redirect stdin with `<`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the `<` operator to redirect standard input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ wc < <textfile>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Heredocs with `<<`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ cat << <someword>`  -- accepts input until <someword> is reached"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Herestring with `<<<`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ cat <<< \"Hello, Linux\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Redirect the `stdout` using the `>` and `>>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ who > file`  -- you can also use `1>`  \n",
    "`$ cat file`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ whoami >> file`  -- append  \n",
    "`$ cat file`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Redirect `stderr` using `2>` and `2>>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ ls /xyz 2> err`  -- no dir called /xyz  \n",
    "`$ cat err`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Combining `stdout` and `stderr`**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ ls /etc /xyz 2> err 1>&2`  -- direct stderr to err file and direct stdout to the same file  \n",
    "`$ ls /etc /xyz 1> err 2>&1`  -- direct stdout to err file and direct stderr to the same file  \n",
    "`$ ls /etc /xyz &> err`  -- same as the above  \n",
    "`$ cat err`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ignoring Error Messages with `/dev/null`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ ls /xyz 2> /dev/null`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Piping using `|`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A pipe is a method of connecting the stdout of one process to the stdin of another process. There are two types of pipes: _named_ and _unnamed_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ cat /etc/hosts | wc -l`  -- pipe the content of the /etc/hosts file to the wc command to count the number of lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a list of commands performed as a group and can be called from other programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "function_name () { \n",
    "   list of commands\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "$ testf()\n",
    "> {\n",
    "> date\n",
    "> echo $HOSTNAME   \n",
    "> }\n",
    "$ testf\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To view functions**  \n",
    "`$ declare -f`  -- list all functions  \n",
    "`$ declare -f testf`  -- list the definition of testf function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To remove functions from memory**  \n",
    "`$ unset <functionname>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To persist functions store it in `~/.bashrc`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shell Built-in Commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Linux shells come with built in commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To view the list of built in commands**  \n",
    "`$ help`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To check whether a command is built in or not**  \n",
    "`$ type <command>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## External Commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "External commands are file-based commands. Normally read from path specified in `PATH` variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ echo $PATH`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using the `which` Command**  \n",
    "`$ which -a <keyword>`  -- lists the aliases and external commands associated with a keyword.  \n",
    "`$ which -a pwd`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ whereis <command>`  -- locates the binary, source and manual page files for a command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# File Management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding the Filesystem Hierarchy Standard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/fhs.jpeg\" alt=\"drawing\" width=\"900\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Files, Filenames and Inodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Linus file = filename + inode + data block(s)  \n",
    "Linux OS uses inode number not filename  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "inode is an internal storage associated with each file containing the following info:  \n",
    "- Permissions\n",
    "- number of links  \n",
    "- user and group owner  \n",
    "- file size\n",
    "- timestamps\n",
    "- pointers to data blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ ls -i`  -- use the `-i` to show the inode numbers  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ stat <filename>` -- shows file status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Soft and Hard Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links are references to files  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hard Links**  \n",
    "- A hard link associates the file's name with the file's inode.  \n",
    "- Use the `ln` command to create additional hard links.  \n",
    "- Hard links work only within the same filesystem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ln <source_file> <destination_file>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ echo 0123456789 > original`  -- creates a file with some text  \n",
    "`$ ls -il or*`  -- will show the file details along with the inode number  \n",
    "`$ ln original orhlink`  -- creates a hard link called orhlink to original file  \n",
    "`$ ls -il or*`  -- will show both files details along with the inode numbers  \n",
    "`$ rm original`  -- this will remove the original hard link but the data blocks will remain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Soft Links**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A symblic/soft link can reference a file from anywhere including network\n",
    "- soft links have their own inode numbers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ln -s <source_file> <destination_file>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Removing links**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`unlink <sym/hardlink>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copying, moving, deleting and renaming files and directories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ cp file1 file2` -- creates a copy of file1 into file2 in the same directory  \n",
    "`$ mv file1 /path/to/new/dir/file1`  -- moves file1 to a new directory keeping the same file name  \n",
    "`$ mv file1 file2`  -- renames file1 to file2  \n",
    "`$ mv dir1 dir2 dir3 /path/to/new/location`  -- moves 3 directories at once into a new location"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Viewing File Contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `cat` -- content in plain text \n",
    "- `less`  -- called a pager displaying one page at a time\n",
    "- `more` -- same as less\n",
    "- `head`  -- shows the first 10 lines\n",
    "- `tail`  -- last 10 lines\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting files and directories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `$ rm <filename>`\n",
    "- `$ rm -r <dirname>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`find <start_directory> <expression>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`<expression>` -- be regex  \n",
    "`-name`  -- matches name of the file  \n",
    "`-size`  -- matches file size `b` blocks, `c` bytes, `w` words, `k` kilobytes, etc.  \n",
    "`-inum`  -- inode  \n",
    "`-user`  -- owner user  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Examples**  \n",
    "`$ find / -size +10M`  -- find all files in the filesystem that are larger than 10MB  \n",
    "`$ find /var/lib code[123]` -- find all files under /var/lib with the names code1, code2 or code3  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Execute commands on the results of the find**  \n",
    "`$ sudo find / -size +1 -exec cp {} ~ \\;`  -- find any files larger than 1GB then copy them to my home dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `grep`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "“global regular expression print”, is a command used in searching and matching text files contained in the regular expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ grep <regex> <filename>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ grep \"localhost\" /etc/hosts`  -- find \"localhost\" string in the /etc/hosts file  \n",
    "`$ grep -r \"localhost\" /`  -- find \"localhost\" string recursively in any location under the root dir  \n",
    "`$ grep -ri \"localhost\" /`  -- add -i to ignore case sensitivity  \n",
    "`$ grep -c \"localhost\" /etc/hosts`  -- -c to count the number of lines where the string was found  "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "-c : This prints only a count of the lines that match a pattern  \n",
    "-h : Display the matched lines, but do not display the filenames.  \n",
    "-i : Ignores, case for matching  \n",
    "-l : Displays list of a filenames only.  \n",
    "-n : Display the matched lines and their line numbers.  \n",
    "-v : This prints out all the lines that do not matches the pattern"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `grep` with regex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ grep f grocery.txt`  -- any occurrence of 'f'  \n",
    "`$ grep ^f grocery.txt -i`  -- must start with 'f' lower or upper  \n",
    "`$ grep f....l grocery.txt -i`  -- anything with f and l but must have exactly 4 letters in between  \n",
    "`$ grep co.n grocery.txt -i`  -- anything with co then one letter then n  \n",
    "`$ grep co[rT]n grocery.txt -i`  -- anything with co then either r or T then n  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `grep` with pipe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ ls | grep file`  -- finds a file called file in the ls list  \n",
    "`cat /etc/hosts | grep localhost`  -- find the string localhost in the output pf /etc/hosts content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ touch file{1..100}`  -- creates 100 files: file1, file2, ..., file100  \n",
    "`$ ls file* | grep file[1]` -- finds any file that starts with file1*  \n",
    "`$ ls file* | grep file.*[12]$`  -- finds any file that ends in 1 or 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Archiving and Compressing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Archiving using `tar`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Archive is a single file that contains a collection of other files and/or directories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ tar -cvf <archive name> </path/to/file/or/directory>`"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "c- Create an archive.\n",
    "v- Verbosely list files.\n",
    "f- Use a specific archive file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "$ tar -cvf home.tar ~ # archive the home dir to home.tar archive\n",
    "$ ls home*\n",
    "$ file home.tar\n",
    "$ rm home.tar\n",
    "$ tar -cvf /tmp/home.tar ~ -C /tmp # save the archive to the /tmp dir\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**list the content of an archive**  \n",
    "`$ tar -tvf /tmp/home.tar`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Extract archives**  \n",
    "`$ tar -xvf /tmp/home.tar /tmp`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compressing using `gzip`, `bzip2` and `xzip`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using `tar` to compress using `gzip`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ tar -cvzf /tmp/home.tar.gz ~  # use the -z to compress by gzip algorithm`  \n",
    "`$ time tar -cvzf /tmp/home.tar.gz ~  # use the time command to see how long it took to execute/compress`  \n",
    "`$ file /tmp/home.tar.gz # check the file type`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using `tar` to compress using `bzip2`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ time tar -cvjf /tmp/home.tar.gz ~  # use the time command to see how long it took to execute/compress using the bzip2 algorithm`  \n",
    "`$ file /tmp/home.tar.bz2 # check the file type`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using `tar` to compress using `gzip`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ time tar -cvJf /tmp/home.tar.gz ~  # use the time command to see how long it took to execute/compress using the xzip algorithm`  \n",
    "`$ file /tmp/home.tar.xz # check the file type`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using `tar` to decompress the file**  \n",
    "```\n",
    "$ tar -xvzf /tmp/home.tar.gz -C /tmp\n",
    "$ tar -xvjf /tmp/home.tar.bz2 -C /tmp\n",
    "$ tar -xvJf /tmp/home.tar.xz -C /tmp\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using gzip to compress/decopress data**\n",
    "```\n",
    "$ gzip -c file1 > file2.gz\n",
    "$ gzip -d file2.gz\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using bzip to compress/decopress files**\n",
    "```\n",
    "$ bzip2 -z file.txt\n",
    "$ bzip2 -d file.txt.bz2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# User Account Management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attributes of a User Account"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Each user account has a line in `/etc/passwd`  \n",
    "- User name\n",
    "- User password\n",
    "- User identification number (UID) -- unique to each user\n",
    "- Group identification number (GID) -- primary group\n",
    "- Comment or GECOS information -- optional \n",
    "- Home directory -- where the user will be when they log in\n",
    "- Login shell -- the program that will be run when the user logs in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Determine the Current User**  \n",
    "`$ who`  -- show who is logged on  \n",
    "`$ whoami` -- print effective user name  \n",
    "`$ id` -- print real name, username and group IDs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Startup Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Files that determine execution environment for shells (window or script)  \n",
    "* Environemt Variables\n",
    "* Aliases\n",
    "* Functions\n",
    "* Shell Options\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Startup Files Order**  \n",
    "1. `/etc/profile`\n",
    "2. `~/.bash_profile` \n",
    "3. `~/.bash_login` \n",
    "4. `~/.profile`  \n",
    "5. `~/.bashrc`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating User Accounts with `useradd`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ sudo useradd sayed`  \n",
    "The following will happen  \n",
    "- UID will be assigned to sayed\n",
    "- A group with the same name as the user will be created\n",
    "- GID will be assigned to sayed (will be same as UID)\n",
    "- Home directory will be created for sayed\n",
    "- Shell will be assigned to sayed (by default `/bin/bash`)\n",
    "- /etc/passwd will be updated\n",
    "\n",
    "The defaults can be overruled by using options to `useradd` as in:  \n",
    "`$ sudo useradd -u 1001 -g 1001 -d /home/sayed -s /bin/sh -p sayed_beh_eshta -c \"sayed kabaka\" sayed` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying and Deleting User Accounts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Delete a user**  \n",
    "`$ sudo userdel <username>`  \n",
    "`$ sudo userdel sayed`  \n",
    "All references to the user 'sayed' are removed from the system except the home dir.\n",
    "`/etc/passwd`  \n",
    "`/etc/shadow`  \n",
    "`/etc/group`  \n",
    "`/etc/gshadow`  \n",
    "\n",
    "`$ sudo userdel -r sayed` -- '-r' will also delete the home dir.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Modify a user account**  \n",
    "`$ sudo usermod <options> <username>`  \n",
    "`-a` -- add the user to the supplementary group(s)  \n",
    "`-G` -- a list of supplementary groups which the user is also a member of  \n",
    "`-l` -- new value of the login name  \n",
    "`-L` -- lock the user account  \n",
    "`-U` -- unlock the user account  \n",
    "`-d` -- new home directory for the user account  \n",
    "`-m` -- move the content of the user's home directory to the new location  \n",
    "`-s` -- new login shell for the user account  \n",
    "`-p` -- new encrypted password of the user account  \n",
    "`-c` -- new value of the user's password expiry date  \n",
    "\n",
    "\n",
    "`sudo usermod -p P@ssw0rd sayed`  -- change password of user sayed to P@ssw0rd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**User Passwords**  \n",
    "To set the user password at creation time:  \n",
    "`useradd -m -p P@ssw0rd username`  \n",
    "\n",
    "To change the user password:  \n",
    "`sudo passwd username`  \n",
    "`sudo usermod -p P@ssw0rd username`  \n",
    "\n",
    "But there's a difference between both methods. The first one sets the password in the `/etc/shadow` file in clear text, while the second one sets the password in the `/etc/shadow` file as a hash."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The `root` Account**  \n",
    "The `root` account is the superuser account. It has the highest level of access to the system. The `root` account is disabled by default in Ubuntu, but you can enable it by setting a password.  \n",
    "\n",
    "**The `sudo` Command**  \n",
    "The `sudo` command allows you to run programs with the security privileges of another user (by default, as the superuser). It prompts you for your personal password and confirms your request to execute a command by checking a file, called `sudoers`, which the system administrator configures.  \n",
    "\n",
    "**The `sudoers` File**  \n",
    "`/etc/sudoers` -- The `sudoers` file contains the rules that users must follow when using the `sudo` command.  \n",
    "\n",
    "**The `visudo` Command**  \n",
    "`visudo` -- The `visudo` command opens the `sudoers` file in a text editor.  \n",
    "\n",
    "**The `su` Command**  \n",
    "`su` -- The `su` command allows you to switch to another user account and creates a sub-shell.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linux Groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating groups using `groupadd`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ groupadd testgroup`  -- creates a group called testgroup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting groups using `groupdel`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ groupdel testgroup`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding users to groups using `usermod`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ usermod -aG <groupname> <username>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SSH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To connect to remote machine shells**  \n",
    "`ssh <username>@<ip-address>` -- Connect to remote machine  \n",
    "`ssh -l <username> <ip-address>` -- Connect to remote machine  \n",
    "`ssh <username>@<ip-address> -p <port-number>` -- Connect to remote machine on a specific port  \n",
    "`ssh <username>@<ip-address> -i <path-to-private-key>` -- Connect to remote machine using a private key  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Copy files to and from remote computers using SSH and SCP**  \n",
    "`scp -r user@remote_host:/path/to/remote/file /path/to/local/file`  -- copy file from remote host to local host\n",
    "`scp -r /path/to/local/file user@remote_host:/path/to/remote/file`  -- copy file from local host to remote host  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Single sign-on**  \n",
    "To configure passwordless login using SSH (Signle Sign-On) you will need to configure public ket cryptography files.  \n",
    "The files exist under the directory `.ssh` under each user's home directory.  \n",
    "The files are:  \n",
    "- `id_rsa`: the user's private key\n",
    "- `id_rsa.pub`: the user's public key\n",
    "- `authorized_keys`: public keys that are permitted to log in\n",
    "- `known_hosts`: hosts from which logins have been allowed in the past\n",
    "- `config`: file for specifying various options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Steps to remote ssh without password (i.e. using publib key cryptography)**  \n",
    "1- `$ ssh-keygen -t rsa`  -- generate pub/priv key pair  \n",
    "2- `$ ls -a`  -- examine the newly created files (id_rsa and id_rsa.pub)  \n",
    "3- `$ cat ~/.ssh/id_rsa`  -- check the content of the private key  \n",
    "4- `$ cat ~/.ssh/id_rsa.pub`  -- check the content of the public key  \n",
    "5- `$ ssh-copy-id -i id_rsa.pub <username>@<remoteip>` -- copy the public key to the remote server  \n",
    "6- `remotessh$ cat ~/.ssh/authorized_keys` -- examine the contents of the remote authorized keys file and verify it now has the content of the public key we just created. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SSH in VSCODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Remote - SSH Extension](https://code.visualstudio.com/docs/remote/ssh)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Managing Ownership and Permissions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managing File Ownership"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ ls -l`  -- views files and directories along with their permissions and owners"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Permissions are `read`, `write` and `execute`.  \n",
    "By default the owner of a file or a directory in linux system receives read, write and execute permissions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Change the ownership of a file or directory using `chown`**  \n",
    "`$ chown <newowner> <filename>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "$ touch file1\n",
    "$ ls -l file1\n",
    "$ sudo chown root file1\n",
    "$ ls -l file1\n",
    "$ sudo root:sami file1\n",
    "$ ls -l file1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managing File and Directory Permissions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Permissions](./images/permissions.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These permissions are assigned to each of three different entities for each file and directory in the filesystem:\n",
    "\n",
    "- **owner/user(u)**  This is the end user that has been assigned to be the file’s or directory’s owner. Permissions assigned to the owner or user apply only to that end user’s account.  \n",
    "- **group(g)**  This is the group that has been assigned to the file or directory. Permissions assigned to the group apply to all accounts that are members of that group.  \n",
    "- **world/other(o)**  This entity, also known as world or other, refers to all other users who have successfully authenticated to the system but are neither the owner nor belong to the  \n",
    " group. Permissions assigned to this entity apply to these user accounts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first column displayed is the mode for each file and directory.  \n",
    "The first character of the mode denotes the file type, which can be a regular file (-),   \n",
    "a directory (d), a symbolic link (l), a block device (b), or character device (c)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "| User | ls output |\n",
    "|------|-----------|\n",
    "|owner |-rwx------ |\n",
    "|group |----rwx--- |\n",
    "|other | -------rwx|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Numerical representation of permissions**  \n",
    "Read: 4  \n",
    "Write: 2  \n",
    "Execute: 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "read + write = 6  \n",
    "read + execute = 5  \n",
    "read + write + execute = 7  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![permnum1](./images/permnum1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![permnum](./images/permnum.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Managing permissions using `chmod`**  \n",
    "`$ chmod u=<rwx>,g=<rwx>,o=<rwx> <filename>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ chmod u=rw,g=rw,o=r somefile`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "$ touch file2\n",
    "$ ls -l file2\n",
    "$ sudo chmod u=r,g=rwx,o=r file2\n",
    "$ ls -l file2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use + and - to toggle on or off specific permissions  \n",
    "`$ sudo chmod g-w file2`  -- removes the write permission from the group on the file  \n",
    "`$ ls -l file2`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Change Permissions Numerically**  \n",
    "`$ touch file3`  \n",
    "`$ ls -l file3`  \n",
    "`$ chmod 660 file3`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Managing Software Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanging Linux package management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Over 60,000 packages so far in the Ubuntu repositories\n",
    "- app stores are all the rage on most platforms; typically, you’ll have one central location from which to retrieve applications, allowing you to install them on your device.  \n",
    "- Linux has had package management since the ‘90s, initially popularized by Debian and then Red Hat.  \n",
    "- Software repositories are generally made available in the form of mirrors.\n",
    "- Not all distributions of Linux feature package management and dependency resolution, but Ubuntu certainly does"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding the differences between Debian and Snap packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- there are actually two completely different types of packages\n",
    "- Ubuntu utilizes **Debian packages** (with package names ending in .deb) as the main package format\n",
    "- Ubuntu and Debian utilize the `apt` and `dpkg` commands to manage packages\n",
    "- Distributions such as CentOS and Red Hat use **RPM packages** for their distributions, and the `dnf` command to manage them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debian packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Debian packages have a filename that ends in `.deb`\n",
    "- When paired with the apt command, they are easy to use and handle dependency resolution\n",
    "- Linux kernel, system packages, libraries, and security updates are all Debian packages that are installed when you install Ubuntu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Snap packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- there’s a push to adopt a single package format that each distribution can install that is independent of the system package type\n",
    "- This concept is known as universal packages, and the idea is to have a standard package type that can be installed on any Linux distribution\n",
    "- universal packages have all of their dependencies built in, so conflicts are less likely to occur; everything the application needs would be contained in one single package\n",
    "- The competing technologies for universal packages include Flatpak, AppImage, and Snap packages.\n",
    "- The type of universal package used in Ubuntu to address these concerns is known as the **Snap package**\n",
    "- Snap packages are better in just about every way and are a great concept than Debian Packages\n",
    "- The only downside might be that they are larger packages, since they include not only the application itself but also all the libraries they require in one single package"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installing and removing software"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Managing Debian packages with `apt`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **APT**, or **Advanced Package Tool**, is a suite of tools that allows us to install, remove, and update Debian packages.\n",
    "- The most popular variation of the apt command is `apt install`.\n",
    "- Example, `$ sudo apt install openssh-server`\n",
    "- You may see longer versions of apt commands, such as `apt-get install` instead of just `apt install`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sudo apt install <package1> <package2> .. <packagen>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What happens when you install a package with `apt`?**  \n",
    "1. Begins with `apt` calculating dependencies.\n",
    "2. Checks whether the package is available.\n",
    "3. Check whether the dependencies are available.\n",
    "4. You can install the suggested packages by adding the `--install-suggests` option to the `apt install` command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![apt install apache2](./images/installingapache2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- When you install a package with the apt command, it searches its local database for the package you named. If it doesn’t find it, it will throw an error\n",
    "- Ubuntu’s repositories move very quickly; new versions of packages are added almost daily\n",
    "- When a new version of a package is added, its older equivalent may be removed\n",
    "- For this reason, it’s recommended that you update your package sources from time to time using `sudo apt update`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `sudo apt update` -- updates the local package index files  \n",
    "- The local index files are in `/var/lib/apt/lists`\n",
    "- Try `cat us.archive.ubuntu.<xyz>-amd64_Packages`\n",
    "- Try `cat us.archive.ubuntu.<xyz>-amd64_Packages | grep ^package -i`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Removing packages**  \n",
    "`sudo apt remove <package>`  \n",
    "Exmaple:  \n",
    "```\n",
    "$ sudo apt install tree -y\n",
    "$ sudo apt remove tree -y\n",
    "```  \n",
    "`$ sudo apt remove --purge tree  # use the --purge to also remove the configuration directory`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Upgrade packages**  \n",
    "`sudo apt upgrade `"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![apt commands](./images/apt.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install packages using `dpkg`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- dpkg is a command-line tool used to install packages\n",
    "- Syntax: `sudo dpkg -i package_name.deb`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Debian package naming convention**  \n",
    "- The syntax is `<package_name>_<version>_<architecture>.deb`\n",
    "- Example: `3dchess_0.8.1-16_i386.deb`"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "-b  --build   (Build package from directory)  -l  --list         (List packages matching pattern)  -V  --verify  (Verify contents of package)  \n",
    "-c  --contents       (List contents of .deb)  -P  --purge                         (Purge package)  --configure            (Configure package)  \n",
    "-I  --info           (Show .deb information)  -r  --remove                       (Remove package)  --force-all     (Continue on all problems)  \n",
    "-i  --install         (Install .deb package)  -S  --search  (Search for packages containing file)  --unpack             (Unpack .deb package)  \n",
    "-L  --listfiles  (List contents of packages)  -s  --status              (Print status of package)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![dpks](./images/dpkg.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Managing Snap packages with `snap`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To search for Snaps**   \n",
    "`$ snap find nmap`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To install Snaps**  \n",
    "`sudo snap install nmap`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Locate installed packages using `which`**  \n",
    "`which nmap`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also install nmap using apt  \n",
    "`sudo apt install nmap`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The nmap installed using `snap` will be stored in `/snap/bin/nmap`\n",
    "- The nmap installed using `apt` will be stored in `/usr/bin/nmap`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remove installed snaps**  \n",
    "`$ sudo snap remove nmap`  \n",
    "**Update installed snaps**  \n",
    "`$ sudo snap refresh nmap`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**update all snap packages**  \n",
    "`$ sudo snap refresh`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Searching for packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ apt search <search term>`  \n",
    "Example:  \n",
    "`$ sudo apt search tree`  \n",
    "`$ sudo apt search tree | grep ^tree`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To get more information about the package**  \n",
    "`$ sudo apt-cache show tree`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Also you can search and get more information on the [Ubuntu Packages Search](https://packages.ubuntu.com/)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managing package repositories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- repositories that come pre-installed with Ubuntu will suffice for the majority of the Debian packages\n",
    "- you may need to install an additional repository in order to take advantage of software not normally provided by Ubuntu\n",
    "- Adding additional repositories allows you to subscribe to additional sources of software and install packages from them in the same way as you would from any other source."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding additional repositories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Software repositories are essentially URLs in a text file, stored in one of two places\n",
    "    - `/etc/apt/sources.list`\n",
    "    - files with an extension of `.list` are read from the `/etc/apt/sources.list.d/` directory\n",
    "- A typical repository line in either of these two files will look similar to the following:\n",
    "    - `deb http://us.archive.ubuntu.com/ubuntu/ jammy main restricted`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `deb` or `deb-src`: references whether the `apt` command will find binary packages (`deb`) or source packages (`deb-src`) there\n",
    "- the actual `URL` that apt will use in order to reach the repository\n",
    "- the codename of the release (`jammy`)\n",
    "- The `component`: references whether or not the repository contains software that is free and open source, and is supported officially by Canonical:\n",
    "    - `main`: component include officially supported software\n",
    "    - `restricted`: still supported but may have a questionable license\n",
    "    - `universe`: packages are supported by the community, not Canonical themselves\n",
    "    - `multiverse`: packages contain software that is neither free nor supported, which you would be using at your own risk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**GNU Privacy Guard (GnuPG)**  \n",
    "The GNU Privacy Guard (GnuPG) is a **public key cryptography implementation** that allows for the secure transmission of information between parties and can be used to verify that the origin of a message is genuine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have the repository (and possibly the key) installed on your server, you’ll need to run the following command to update your package index:  \n",
    "`sudo apt update`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Personal Package Archive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- PPAs are essentially another form of APT mini-repository\n",
    "- PPAs are usually very small repositories (sometimes with a single app)\n",
    "- Sometimes vendors make an app available through source code you download, compile and install\n",
    "- PPAs are generally added to your server with the `apt-add-repository` command\n",
    "- Example: `sudo apt-add-repository ppa:username/myawesomesoftware-1.0`\n",
    "- **Ubuntu PPA website is available here [Personal Package Archives for Ubuntu](https://launchpad.net/ubuntu/+ppas)**\n",
    "- `apt-add-repository` command is essentially automating the process of adding a repo file to the `/etc/apt/sources.lis.d` directory and installing its key\n",
    "- You can uninstall a PPA by simply deleting its file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cleaning up orphaned apt packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Someetimes you’ll have packages on your system that are installed but not needed by anything\n",
    "- This occurs either when removing a package that has dependencies\n",
    "- use the `sudo apt autoremove` command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Package Management](https://ubuntu.com/server/docs/package-management)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Storage Management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding Linux Storage Solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![HD Partitions](./images/hdpartitions.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Master Boot Record (MBR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Public in 1983 with PD DOS\n",
    "- 512 bytes sector size (2^23 x 512 bytes)\n",
    "- 2TB maximum size\n",
    "- 4 Partitions max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![MBR](./images/mbr.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![EMBR](./images/embr.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GUID Partition Table (GPT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 4KB sector size\n",
    "- 64 bits addressing scheme for Logical Block Addresses (LBA)\n",
    "- 2^64 sectors (if disk sector size is 512b => max size is 8ZB = 2*64 x 512b)\n",
    "- Redundancy, because the partition header and table details are stored at the beginning and end of the drive\n",
    "- Human-readable partition names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Devices in Linux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The Device Naming Conventions**  \n",
    "A device name format is xxyz, where  \n",
    "- _xx_ is the device type.\n",
    "- _y_ indicates the device’s logical unit number.\n",
    "- _z_ indicates the partition number.\n",
    "\n",
    "**Device Type (_xx_)**  \n",
    "Some examples of device types include storage devices, such as sd (SCSI/SATA devices) and hd (IDE hard drives). Other devices include terminals, such as tty (text terminals) and pts (pseudo-terminals).  \n",
    "\n",
    "**Logical Unit Number (_y_)** \n",
    "Next, the device name contains the device’s logical unit number, a unique identifier for a device within a group of devices. For example, a system may have multiple SCSI devices (device type sd). To distinguish one SCSI device from another, each SCSI device is assigned a unique identifier. Logical unit sda refers to the first SCSI device. The second SCSI device would be sdb. Also,\n",
    "\n",
    "- _tty1_ refers to the first text terminal.\n",
    "- _pts/0_ refers to the first pseudo-terminal.\n",
    "- _lp0_ refers to the first printer.\n",
    "- _st0_ refers to the first SCSI tape drive.\n",
    "- _sr0_ refers to the first optical (CD/DVD) drive\n",
    "\n",
    "**Partition Number (z)**  \n",
    "A block device may be split into numbered partitions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![devices](./images/lsblk.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `# cd /dev`\n",
    "- `# ls`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Additional Volumes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Partitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`# fdisk /dev/sdb`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatting Partitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Formatting a partition is creating a filesystem based on the filesystem types available:  \n",
    "- Available filesystem types are in `/lib/modules/<kernel-version>/fs`\n",
    "- `# cd /lib/modules/$(uname -r)/kernel/fs`\n",
    "- `# cat /proc/filesystems`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Use `mkfs` command to format**   \n",
    "`# mkfs -t ext3 /dev/sdb1` -- make sure to do this after creating the partition and before mounting it  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Putting them all together**  \n",
    "- **Viewing all storage** \n",
    "- `# ls /dev`\n",
    "- `# lsblk -lf`\n",
    "- `# fdisk -l`\n",
    "- `# df -h`  -- you can add -a to show inaccessible devices\n",
    "- **Creating/Deleting a partition**\n",
    "- `# fdisk /dev/sdb`  -- for an MBR partition\n",
    "- `# gdisk /dev/sdb`  -- for a GPT partition\n",
    "- **Create a volume**\n",
    "- `# mkfs -t ext4 /dev/sdb1`\n",
    "- **Mount a volume**\n",
    "- `# mkdir /o`\n",
    "- `# mount /dev/sdb1 /o`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mounting and Unmounting Volumes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical Volume Management (LVM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Managing Linux Processes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding Linux Processes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types of Linux Programs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![devices](./images/LinuxPrograms.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How Linux Programs are Loaded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![devices](./images/GenofProcs.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![devices](./images/systemd.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![devices](./images/ppid.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Starting a System Process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `init` or a `service file`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`/etc/init.d/<script_name> start | stop | restart`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the distro uses `systemd`:  \n",
    "`systemctl status | start | stop | enable`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Viewing Running processes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ps`  # Displays a snapshot of the running processes within the current terminal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `ps` # all procs within current terminal\n",
    "- `\n",
    "ps -`a # all user running proc\n",
    "- `\r\n",
    "ps `-e # all running procs in the syst\n",
    "- `m\r\n",
    "ps` -l # displays ppid uid and stime (start time) c (processor ti\n",
    "- `e)\r\n",
    "p`s -f # more det  ails"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pgrep bash`  \n",
    "`pgrep systemd -l`  \n",
    "`pidof bash`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Managing Foreground and Background Processes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ sleep 10`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ sleep 30`  \n",
    "`$ pidof sleep`   \n",
    "`$ pgrep sleep -l`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Switching Processes Between Background and Foreground"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`fg`  \n",
    "`bg`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Ctrl-z`  to send background"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ending a Running Process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Linux for Data Engineers",
   "toc_cell": false,
   "toc_position": {
    "height": "775px",
    "left": "30px",
    "top": "67.125px",
    "width": "418.391px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}