Learn Linux in 2 Days: Fast Track for Busy Professionals

In this lecture, delve into the fundamental aspects of the Linux command line. Learn how to open a terminal, navigate using basic bash commands, and understand the structure of commands for efficient system management.

In this lecture, discover how to launch and verify Bash in your terminal. We'll cover initial commands like ls for directory viewing and dive into customization options for terminal aesthetics. Learn essential settings to ensure Bash is your default command line interface, streamlining your command execution for efficient system management.

In this lecture, we dive into the structure of a command using echo as our guide. Learn the components of command execution, from calling a program with arguments like 'Bash is amazing!' to utilizing options that modify command behavior, such as omitting line breaks or enabling backslash escapes. This session provides a practical overview of how to effectively use options and parameters to tailor command outputs in your terminal.

In this lecture, explore file navigation techniques in Linux. Discover how to use commands such as pwd to determine your location, ls to reveal directory contents, and cd to change directories. Understand the use of absolute and relative paths for efficient file management across your Linux environment.

In this lecture, learn how to access help directly from the Linux command line when managing files or exploring new commands. Discover how to utilize the -h flags, man pages, and online resources effectively. We'll cover practical examples like using ls --help to reveal command options and man ls to access detailed manuals. This guidance ensures you can navigate Linux commands confidently and resolve issues independently.

In this video, learn how to use the touch and mkdir commands to create files and directories in Linux. Discover the flexibility of creating multiple files simultaneously, updating file timestamps, and setting up nested directory structures with ease. This session showcases the powerful capabilities of command line tools for efficient file and folder management.

In this video, learn how to move and copy files using the Linux command line. Discover how to efficiently use the mv command to both relocate and rename files, including handling multiple files at once. We also explore the cp command for duplicating files and directories, emphasizing the use of the recursive option for copying entire folders.

In this video, learn the crucial steps for deleting files and folders using the Linux command line. Discover how to use the rm command to remove files or entire directories with the -r option for recursive deletion. Additionally, explore the rmdir command, which safely removes empty directories, ensuring you don't accidentally delete content.

In this exercise, manage and extract photos using Linux commands. Work with .zip files, filter out specific formats like .mov and .HEIC, and organize .jpeg files into a new folder. Follow step-by-step instructions to apply command-line skills in real-world scenarios, such as preparing images for professional printing.

In this video, we walk through the solution to the photo extraction exercise. Learn how to efficiently remove .HEIC and .mov files and organize your .jpeg images by moving them to a designated folder. This lecture demonstrates using the rm command to delete files and the mv command to relocate .jpeg files to a new directory on the desktop. Follow these steps to streamline your file management tasks and prepare images for sharing or printing.

In this video, we introduce the chapter on managing text files in Linux. We'll cover how to read and search files using tools like less and nano, and explore handling large log files efficiently. This overview sets the stage for deeper practical exercises later in the chapter, where you will apply these techniques to real-world data scenarios.

In this video, we preview the employee contribution data that we'll analyze throughout this chapter. We'll look at the structure of the data, stored in a zip file, and discuss its significance for upcoming Linux terminal operations. This session prepares us for deeper data manipulation and analysis in subsequent lectures.

In this video, we explore how to output entire files and specific sections to the terminal using Linux commands like cat, head, and tail. Learn techniques for efficiently managing file contents, including how to view the beginning and end of files, and how to monitor live updates from log files using the tail command with the -f option. This video provides essential skills for handling files on remote servers and managing large data sets effectively.

In this video, explore the functionality of nano for text editing on Linux. We cover opening, navigating, and editing files within the terminal, highlighting key shortcuts for exiting, saving, and manipulating text. This session is designed to equip you with the necessary skills for efficient file management and configuration directly from the command line.

In this video, we delve into techniques for working with large files on Linux. Learn how to use the wc command to count words, lines, and bytes before opening a file, ensuring efficient data handling. We also introduce the less command for navigating large files without loading them entirely, demonstrating navigation shortcuts and search functions within the less interface. This session is essential for managing substantial data efficiently, especially on remote servers.

In this video, learn to calculate disk space usage for files and directories using Linux commands. We cover how to interpret disk space requirements and demonstrate the use of summary and apparent size flags to manage storage effectively. This guide is essential for optimizing file system storage, particularly useful in server management and data-heavy environments.

In this exercise, use Linux command line tools to analyze contribution files. You'll identify key details such as software version releases, employee contributions by line count, the latest commits, and specific project tasks. This hands-on task reinforces file analysis skills through practical application of previously discussed commands.

In this video, we review the solutions to the file analysis exercise. Follow along as we verify the launch date of a software version, identify which employee's files contain the most lines, determine who made the latest commit, and ascertain whether an employee worked on a specific project part. This session guides you through using various command line tools to analyze contribution files effectively, demonstrating multiple methods to reach the correct conclusions.

In this video, we recognize your progress in mastering the Linux terminal. You've learned to manage files, handle large logs, and use basic commands. Up next, we'll explore user management, permissions, and the use of sudo for advanced tasks. Prepare for more exciting topics as you continue your journey into Linux expertise!

In this video, we cover essential Linux concepts including user management, file permissions, and package management. Discover the role of sudo, how to adjust file permissions, and manage system updates efficiently. We focus on practical understanding over rote memorization, using graphical interfaces and command line tools. Get ready to effectively manage Linux systems and communicate with AI as we prepare for more advanced topics.

In this lecture, we delve into the different user types in Linux: system accounts, regular users, and the super user. Discover how system accounts handle background tasks, how regular users manage their files, and how the super user root has full control over the system. Using the graphical system monitor and htop, we demonstrate user operations and process management. This foundational knowledge prepares us for more detailed user management in the next lecture.

In this video, explore how to manage users in Linux through the graphical user interface. Discover how to add and configure user accounts, manage permissions, and switch user sessions. We'll also demonstrate how administrators can elevate their privileges for restricted tasks, emphasizing both accessibility and security. Get ready for more advanced user management strategies in future lectures.

In this video, learn how to use the sudo command to elevate privileges on Linux, essential for remote server tasks or when a GUI isn't available. We'll demonstrate how to execute commands with higher privileges, access directories like /root, and handle sudo's limitations with certain commands. The video also covers launching a root shell with sudo -s for comprehensive system management, highlighting the importance of understanding these commands for security.

In this video, discover how the su command on Linux allows you to switch user accounts, requiring the target user's password unlike sudo. We'll show how to log into various user profiles and manage permissions, emphasizing the security advantages of separate credentials for regular and administrative tasks.

In this video, we uncover where user information is stored in Linux. Explore essential system files such as /etc/passwd for basic user account details, /etc/shadow for encrypted passwords and password management data, and /etc/group for group memberships. We'll demonstrate each file's accessibility and contents, showing how Linux manages user data securely and efficiently. This foundational knowledge sets the stage for more detailed discussions on user groups in the next lecture.

In this video, explore how Linux uses groups to manage permissions and secure systems. Discover the impact of primary and secondary group memberships on file ownership and user permissions. We'll show how to check group ownership and how secondary groups enhance access control and support command-specific permissions like sudo. This lays the groundwork for upcoming discussions on file permissions.

In this video, learn the fundamentals of file permissions in Linux, key to securing file and directory access. Discover the roles of user classes and permission bits like read, write, and execute. We'll show you how to view and interpret permission settings with ls -l, preparing you for upcoming lectures on enhancing system security.

In this video, explore chmod and chown commands to manage file permissions and ownership in Linux. Learn to adjust permissions symbolically and numerically, and apply changes across directories. Gain essential skills for effective system administration and troubleshooting.

In this video, discover how to manage software in Linux with the apt tool, essential for installing, updating, and removing applications. Learn how apt works with online repositories to manage package dependencies and keep your system up-to-date. We'll demonstrate updating package lists, installing software like cowsay, and removing applications to free up space.

In this video, deepen your understanding of Linux package management using the apt tool, focusing on upgrading software with apt upgrade and apt full-upgrade. Learn how to manage dependencies with apt auto-remove and resolve conflicts with apt install -f, equipping you to maintain and optimize your Linux system effectively.

In this video, we acknowledge the essential Linux skills you've developed throughout this chapter, from mastering user management to updating systems. Next, we'll dive into advanced shell scripting, explore command syntax nuances, and set up a server. Your journey has been impressive, with more in-depth topics awaiting in upcoming chapters.

In this video, we set the stage for our exploration of streams and pipes in Linux, two pivotal concepts that enhance your command-line proficiency. You'll get an overview of how these features allow for redirecting outputs, handling inputs and errors, and linking commands to construct complex operations. This chapter prepares you to understand the practical uses of streams and pipes, such as managing large log files and storing command results effectively.

In this lecture, we explore how to redirect the output of a command into a file using redirection operators. You'll learn how to store command results in a file, how existing files are overwritten or appended to, and how this technique applies to various commands beyond simple text output. We also touch on an important distinction—why some outputs are stored in a file while error messages still appear in the terminal. This sets the stage for the next lecture, where we’ll dive deeper into handling errors with redirection.

In this lecture, we dive into the concept of standard streams in Linux: standard input, standard output, and standard error. You'll learn how these streams function and why some outputs are redirected into a file while others still appear on the terminal. We explore how to explicitly redirect standard output and standard error separately, as well as how to store them in different files. This foundational knowledge will help you better control command outputs, troubleshoot errors, and prepare for more advanced redirection techniques. In the next lecture, we’ll see how to redirect both streams into the same file.

In this lecture, we explore how to redirect both standard output and standard error into the same file. You'll learn the correct approach to ensure all output is captured properly, avoiding common pitfalls like file overwriting and unintended output loss. We demonstrate the importance of command order when redirecting streams and how to efficiently store all program outputs for debugging. In the next lecture, we’ll shift our focus to handling input redirection in Linux.

In this lecture, we explore how to redirect input from a file into a program using standard input redirection. You'll see how certain commands, like wc, can accept user input directly and how we can use file redirection to automate this process. While many Linux tools can open files directly, input redirection becomes crucial when working with programs that require manual input. Mastering this technique will prepare you for the next step—combining commands using pipes, which we will explore in the second half of this chapter.

In this lecture, we explore pipes - a powerful way to connect commands by passing the output of one as input to another. You'll learn how to replace temporary files with efficient command chaining, making workflows more streamlined. We also discuss how standard output flows through pipes and how to handle standard error. In the next lectures, we’ll explore additional tools to enhance the power of pipes.

In this lecture, we explore the tee command, a useful tool for writing command output to a file while simultaneously displaying it in the terminal. You'll see how tee is especially helpful for monitoring real-time output from long-running commands while keeping a saved copy for later analysis. We also demonstrate how to append output using the -a flag and discuss practical use cases, such as logging software updates.

In this lecture, we explore the grep command, a powerful tool for searching patterns in files and command output. You'll learn how to use grep to filter log files, search within compressed files using pipes, and apply basic and advanced pattern matching. We also discuss the -F flag for simple searches and introduce regular expressions for more complex queries. Understanding grep will help you quickly find relevant information in large datasets and system logs.

In this lecture, we explore the cut command, a useful tool for extracting specific portions of data from files or command output. You'll learn how to cut by bytes, characters, and fields, making it especially useful for structured data processing. We demonstrate how to use delimiters to isolate relevant information and show practical examples using system commands like uptime. Mastering cut will help you efficiently extract and manipulate text data in Linux.

In this lecture, we explore how to sort data and identify unique entries using the sort and uniq commands. You'll learn how to organize file contents, remove duplicate lines, and count occurrences of repeated entries. We demonstrate practical examples using system files like /proc/cpuinfo, showing how these tools can help analyze structured data efficiently. These commands are especially useful when working with log files or large datasets. In the next lecture, we’ll introduce another essential tool to enhance your workflow.

In this lecture, we explore the sed command, a powerful tool for searching and replacing text in files or command output. You'll learn how to use sed to substitute patterns, correct misspellings, and modify text efficiently. We also demonstrate the importance of the g flag to replace all occurrences in a line. sed is especially useful when working with pipelines, allowing you to process and clean up text dynamically. In the next lecture, we’ll apply what we’ve learned with an exercise.

In this exercise, you'll apply your knowledge of Linux command-line tools to analyze a dataset containing Bob’s contributions. Using commands like grep, wc, uniq, sort, and pipes, you'll answer key questions, such as:

• How often has Bob contributed to the API?

• What is the total number of commits he has made?

• On how many different days has he contributed?

• Which commit ID comes first alphabetically?

This challenge will help you practice filtering, counting, and sorting data directly in the terminal.

Try to solve it on your own before checking the provided solution in the next lecture!

In this video, we go step by step through the solution to analyze Bob’s contribution data using Linux commands. You'll see how to filter and count specific entries with grep and wc, extract unique dates with sort and uniq, and determine the first commit ID alphabetically. We also explore different ways to achieve the same results, reinforcing the flexibility of pipes and text processing tools. By the end of this lecture, you'll have a solid grasp of applying these techniques to real-world data analysis.

In this video, we introduce the shell environment in Linux and its role in system customization and efficiency. You'll get an overview of key topics like environment variables, configuration files, and aliases, along with practical use cases. By the end of this chapter, you'll know how to configure and enhance your shell for a smoother command-line experience.

In this lecture, we explore environment variables and their role in configuring the shell and influencing program behavior. You'll learn how to view environment variables using the env command, access them correctly with proper syntax, and modify them using the export command. We also demonstrate how these variables affect commands like cd and why changes aren't persisted by default. Finally, we introduce the PATH variable, a crucial element for executing programs, which we'll dive into in the next lecture.

In this lecture, we dive into the PATH variable, one of the most crucial environment variables in Linux. You'll learn how the PATH variable determines which directories are searched for executable programs and why the order of these directories matters. We demonstrate how to check an executable’s location, modify the PATH variable to include custom directories, and create your own executable scripts that can be accessed from anywhere in the terminal. Finally, we discuss best practices for managing the PATH variable to avoid conflicts and maintain system efficiency.

In this lecture, we explore how to make changes to the PATH variable persistent across terminal sessions. You'll learn about Bash startup files and why .bashrc is the recommended place for storing custom configurations. We walk through editing .bashrc using a text editor, adding the necessary modifications, and ensuring the changes take effect each time a new Bash session is started. If you’re curious about the technical details behind Bash startup files, stay tuned for the next, more in-depth lecture.

In this optional lecture, we take a deeper dive into Bash startup files and the different shell types that determine which configurations are loaded. You'll learn about interactive and non-interactive shells, login and non-login modes, and how these influence the initialization process. We also discuss why different startup files exist and how Bash decides which ones to load. If you're curious about the technical details behind Bash initialization, this lecture will provide a thorough explanation.

In this lecture, we explore how environment variables are inherited by child processes and how they can be used to pass configuration data to applications. You'll learn how to set environment variables inline for temporary use, as well as how to use export to make them persist for the duration of a session. We also clarify the difference between Bash variables and environment variables, ensuring you understand which ones get passed to child processes. Finally, we introduce the concept of aliases, which we will explore in more detail in the next lecture.

In this lecture, we explore how aliases can simplify your workflow by shortening long or frequently used commands. You'll learn how to create an alias, execute it as if it were a regular command, and even chain multiple commands together for efficiency. We also demonstrate how to list existing aliases and remove them with the unalias command. Since aliases are temporary by default, we discuss how to make them permanent by adding them to your .bashrc file. Mastering aliases can save time and streamline repetitive tasks in the terminal.

In this lecture, we recap everything you've learned about the shell environment, from understanding and configuring environment variables to distinguishing them from Bash variables. You've also explored aliases, how to chain multiple commands, and how to make your workflow more efficient. With this knowledge, you're now equipped to debug common terminal issues and streamline your command-line experience. Up next, we’ll dive into expansions, including wildcard characters and quoting, to help you work with production systems more safely and effectively.

In this lecture, we introduce Bash expansions, a fundamental feature that simplifies complex Bash operations. Discover how shell expansions dynamically rewrite commands to integrate variables, patterns, and special characters, improving command functionality. We'll outline the benefits and potential risks, such as accidental data loss, to prepare you for safe and effective use of expansions throughout this chapter.

In this video, we introduce the tilde expansion in Bash, demonstrating how the tilde character (~) automatically expands to your home directory. We'll show the practical usage of ls ~ to list the contents of the home folder and explain how echo ~ outputs the home directory path. Further, we explore variations like ~+ for the current working directory, enhancing your command line efficiency. This exploration lays the groundwork for more advanced expansion techniques in Bash.

In this video, we delve into variable expansion and shell parameter expansion in Bash. Discover how variable expansion replaces variables with their actual values to streamline command execution. We'll also cover shell parameter expansion, which enables advanced string operations such as substring extraction and string replacement. Learn practical examples that demonstrate how these expansions enhance scripting efficiency and accuracy, preparing you for further advanced Bash techniques.

In this video, we dive into filename expansions in Bash, focusing on how to efficiently find and manage files using wildcard characters. Learn how the asterisk (* ) and question mark (? ) symbols serve as powerful tools for matching file names and extensions, such as .txt files. We'll demonstrate how these expansions rewrite commands before execution, simplifying the listing and handling of files with commands like ls and echo. Additionally, we explore the square bracket syntax for specifying character ranges, enhancing your ability to filter and retrieve files based on specific patterns. This lecture sets the stage for more advanced command manipulations in Bash, including word splitting, which we will cover next.

In this video, we explore the concept of word splitting in Bash, a crucial process that determines how commands are parsed and executed. Discover how bash separates command inputs into distinct words or tokens, such as differentiating commands from file names using spaces, tabs, or newline characters. We demonstrate practical examples, like creating files using the touch command, to illustrate how Bash handles multiple arguments. Additionally, learn how to control and disable word splitting using quotes to manage filenames with spaces, enhancing your command line proficiency and preparing you for advanced Bash functionalities.

In this video, we explore how quotes affect Bash commands. Understand the distinctions between no quotes, single quotes, and double quotes. No quotes enable all expansions, single quotes block expansions and word splitting, while double quotes allow variable expansion but block others. This concise guide will help you master the use of quotes to refine your Bash scripting skills.

In this video, we discuss the risks of filename expansion in Bash, highlighting how filenames can be mistakenly interpreted as commands or parameters. Learn to avoid pitfalls like unintended deletions by using specific syntax, such as prefixing file paths with ./, to ensure accurate command execution. This concise guide emphasizes safe practices for handling files, particularly in critical environments.

In this video, we delve into command substitution in Bash, a powerful feature that allows you to use the output of one command as input to another. We illustrate this with practical examples, such as calculating the size of your home directory in a human-readable format and counting the files in a directory. Discover how to integrate command outputs seamlessly into new commands using syntax like $(command), enhancing script functionality and automation. This exploration sets the stage for our next topic on escaping in shell scripts, further refining your command line skills.

In this lecture, we delve into escaping in Bash, highlighting the use of the backslash (\) to control command interpretation. Learn how escaping helps disable word splitting, enable literal interpretation of characters like quotes, and manage filenames with spaces. We also discuss the limitations of escaping within single-quoted strings, equipping you with the knowledge to craft precise Bash commands effectively.

In this exercise, we tackle file extraction using Bash expansions. Your challenge is to retrieve specific Excel files from January and February for a hypothetical company preparing for a court hearing. Utilize expansions to select files from nested folders in the purchasing and sales departments and copy them to a designated location. This task demonstrates how to efficiently use custom ranges and wildcards to filter and extract necessary documents. A detailed explanation of the solution will be provided in the next lecture to enhance your command-line proficiency.

In this video, we present the sample solution for our file extraction exercise. We explain how to use Bash expansions to selectively retrieve Excel files from January and February, excluding March. The demonstration covers constructing expressions for navigating department folders and using custom range patterns to target specific months. We also show how to copy the selected files to the desktop, highlighting the command line's efficiency over graphical interfaces for managing large datasets. This approach offers practical insights into advanced file management with Bash.

In this video, we set the stage for deploying your first HTML website to a remote server. We'll overview the key skills you'll learn, including secure server connection using public-private key authentication, file uploads via SSH, and webserver installation. Additionally, we provide a downloadable gym website project to practice with. This chapter is designed to integrate crucial server management techniques, equipping you with practical skills whether you host a webserver or manage different server configurations.

In this lecture, we delve into SSH (Secure Shell ), a key network protocol for secure data communication between a client and server. Learn about setting up SSH clients and servers, including practical details on user logins, managing non-default ports, and preventing unauthorized access. We also outline three paths for hands-on SSH application: using a rented server, converting a personal Ubuntu machine, or installing SSH on a single device. This session prepares you for practical SSH deployment based on your selected approach.

In this video, we outline the options for following along with SSH setups in this chapter. Learn about renting a server from providers like DigitalOcean for short-term use without long-term commitments, using your own Ubuntu virtual machine as a server, or running an SSH server locally on your system to connect via localhost. We recommend the rental approach for a hands-on experience, but also provide guidance for using a personal VM or a local setup. This session ensures you understand all available paths to effectively participate in our SSH exercises.

In this video, we outline the differences between dedicated versus virtual servers, and managed versus unmanaged services. Discover when to opt for a dedicated server for maximum privacy and resource control, and when a virtual server might offer cost benefits with potential security risks. We also compare managed servers, which provide ongoing maintenance but limited customization, to unmanaged servers that grant full control with a need for self-management. This guidance will help you choose an unmanaged virtual server for practical application in your server setup.

In this video, we guide you through the process of renting an unmanaged virtual server on DigitalOcean. We start by signing up on their platform, navigating through the account creation, and entering payment information. Next, we detail how to choose and configure a virtual server, known as a droplet, selecting specifications that balance performance with cost. We demonstrate logging into the newly created server using SSH, managing server settings, and performing software updates entirely via command line. Finally, we discuss the importance of shutting down the server after use to avoid unnecessary charges, preparing you for more advanced server management tasks in subsequent lectures.

In this video, we demonstrate how to set up SSH access to an Ubuntu virtual machine running in VirtualBox from a Windows host. We begin by installing the OpenSSH server on Ubuntu, ensuring it starts automatically. Next, we adjust the network settings from NAT to a bridged connection, allowing the virtual machine to appear as a separate device on the same network. This setup enables direct SSH access from Windows using PowerShell, bypassing the need to rent external servers. Follow along as we guide you through each step to achieve seamless connectivity between your Windows system and Ubuntu virtual machine.

In this video, we cover setting up and using SSH on a single Ubuntu system. Discover how to install OpenSSH server locally and connect to it from the same machine, creating a client-server setup that eliminates the need for external resources. We demonstrate initiating an SSH session to localhost, managing authentication, and exiting the session. This approach allows for practicing SSH without extra costs, ensuring you can master SSH operations in any setting.

In this video, we explore the significance of changing the default SSH port from 22 to minimize unauthorized access attempts and reduce log file clutter. We guide you through installing and configuring an SSH server on Ubuntu, including how to adjust the port settings to a less common one, such as 222. The session includes steps for modifying the SSH configuration file, reloading and restarting the SSH service to implement changes, and tips to prevent locking yourself out of the server. By the end of this lecture, you'll understand how to enhance your SSH setup and maintain cleaner server logs.

In this video, we delve into setting up key-based authentication for SSH, enhancing security beyond traditional password methods. We start by generating a public-private key pair using ssh-keygen and discuss how these keys function together to secure authentication. We'll show you how to install the public key on the server and configure the server's SSH settings to prefer key-based access. This setup prevents brute force attacks and ensures that only authorized users with the correct private keys can access the server. By the end of this session, you will know how to replace less secure password logins with a robust key-based system, preparing you for more advanced server security practices.

In this video, we guide you through the installation of Apache 2 on an Ubuntu server, detailing each step from the initial command to the complete setup. We explain how to navigate the Apache configuration, emphasizing the roles of various directories like mods-enabled and sites-enabled for module and site management. Additionally, we cover the configuration settings for the default site, explain log file locations, and show how to access the server's default page. This lecture equips you with the essential knowledge to set up and monitor a basic webserver, laying the groundwork for more complex server administration tasks.

In this lecture, we delve into managing services on a Linux system using systemctl, specifically focusing on the Apache 2 webserver. We demonstrate essential systemctl commands to start, stop, and check the status of services, ensuring Apache runs automatically at boot or is disabled as needed. Additionally, we explain the differences between restarting and reloading services to apply configuration changes effectively. By the end of this session, you will be equipped to efficiently manage services like Apache using systemctl on your Linux system.

In this lecture, we demonstrate how to upload a website to a server using SCP (Secure Copy Protocol), which utilizes SSH for secure file transfers. We discuss the setup of the var/www/html directory, where Apache serves web files, and show how to transfer an entire website to this location. We explain how to retain file timestamps during the transfer and adjust SSH port settings for SCP. Additionally, we introduce alternative file transfer methods, such as graphical SFTP clients like Cyberduck and Linux file browsers. By the end of this session, you'll know how to efficiently upload and manage your website files on a server, leveraging both command-line and graphical tools.