Enhanced descriptions from Syndetics:

Description

The Linux operating system powers millions of web servers, data centers, and application platforms worldwide. Whether you're pushing applications to a cloud system like AWS, building a twitter bot on a Raspberry Pi, or rescuing files from a crashed laptop, Linux is required knowledge.

Linux in Action is a task-based tutorial that will give readers the skills and deep understanding they'll need to administer a Linux-based system.

Key features

· Hands-on guide

· Step-by-step examples

· Task-based

Audience

Readers should be comfortable working with the files, networks, and basic resources of a modern operating system.

About the technology

Linux makes it possible to do all kinds of really useful and creative things. For instance, you can load a Linux "live boot" image on a USB stick, boot a PC whose own hard disk has been corrupted, and troubleshoot and fix the problem.

Table of contents provided by Syndetics

• Preface (p. xi)
• Acknowledgments (p. xii)
• About this book (p. xiv)
• About the, author (p. xviii)
• About the cover illustration (p. xix)
• 1 Welcome to Linux (p. 1)
• 1.1 What makes Linux different from other operating systems (p. 2)
• 1.2 Basic survival skills (p. 3)
• The Linux file system (p. 4)
• Getting around: Linux navigation tools (p. 5)
• Getting things done: Linux file management tools (p. 9)
• Keyboard tricks (p. 13)
• Pseudo file systems (p. 14)
• Showing 'em who's boss: sudo (p. 15)
• 1.3 Getting help (p. 16)
• Man files (p. 16)
• Info (p. 16)
• The internet (p. 17)
• 2 Linux virtualization: Building a Linux working environment (p. 22)
• 2.1 What is virtualization? (p. 23)
• 2.2 Working with VirtualBox (p. 26)
• Working with Linux package managers (p. 26)
• Defining a virtual machine (VM) (p. 33)
• Installing an operating system (OS) (p. 36)
• Cloning and sharing a VirtualBox VM (p. 39)
• 2.3 Working with Linux containers (LXC) (p. 41)
• Getting started with LXC (p. 41)
• Creating your first container (p. 42)
• 3 Remote connectivity: Safely accessing networked machines (p. 49)
• 3.1 The importance of encryption (p. 50)
• 3.2 Getting started with OpenSSH (p. 51)
• 3.3 Logging in to a remote server with SSH (p. 53)
• 3.4 Password-free SSH access (p. 55)
• Generating a new key pair (p. 56)
• Copying the public key over a network (p. 57)
• Working with multiple encryption keys (p. 59)
• 3.5 Safely copying files with SCP (p. 59)
• 3.6 Using remote graphic programs over SSH connections (p. 60)
• 3.7 Linux process management (p. 61)
• Viewing processes with the ps command (p. 62)
• Working with systemd (p. 64)
• 4 Archive management: Backing up or copying entire file systems (p. 68)
• 4.1 Why archive? (p. 69)
• Compression (p. 69)
• Archives: Some important considerations (p. 70)
• 4.2 What to archive (p. 71)
• 4.3 Where to back up (p. 73)
• 4.4 Archiving files and file systems using tar (p. 74)
• Simple archive and compression examples (p. 74)
• Streaming file system archives (p. 76)
• Aggregating files with find (p. 78)
• Preserving permissions and ownership...and extracting archives (p. 79)
• 4.5 Archiving partitions with dd (p. 83)
• dd operations (p. 83)
• Wiping disks with dd (p. 84)
• 4.6 Synchronizing archives with rsync (p. 85)
• 4.7 Planning considerations (p. 86)
• 5 Automated administration: Configuring automated offsite backups (p. 90)
• 5.1 Scripting with Bash (p. 91)
• A sample script for backing up system files (p. 91)
• A sample script for changing filenames (p. 95)
• 5.2 Backing up data to AWS S3 (p. 97)
• Installing the A WS command-line interface (CLI) (p. 97)
• Configuring your AWS account (p. 98)
• Creating your first bucket (p. 99)
• 5.3 Scheduling regular backups with cron (p. 100)
• 5.4 Scheduling irregular backups with anacron (p. 103)
• Running the S3 sync job (p. 103)
• 5.5 Scheduling regular backups with systemd timers (p. 104)
• 6 Emergency tools: Building a system recovery device (p. 109)
• 6.1 Working in recovery/rescue mode (p. 111)
• The GRUB bootloader (p. 111)
• Using recovery mode on Ubuntu (p. 112)
• Using rescue mode on CentOS (p. 113)
• Finding command-line rescue tools (p. 113)
• 6.2 Building a live-boot recovery drive (p. 114)
• System rescue images (p. 115)
• Writing live-boot images to USB drives (p. 116)
• 6.3 Putting your live-boot drive to work (p. 120)
• Testing system memory (p. 120)
• Damaged partitions (p. 122)
• Recovering files from a damaged file system (p. 124)
• 6.4 Password recovery: Mounting a file system using chroot (p. 126)
• 7 Web servers: Building a MediaWiki server (p. 130)
• 7.1 Building a LAMP server (p. 131)
• 7.2 Manually setting up an Apache web server (p. 133)
• Installing the Apache web server on Ubuntu (p. 133)
• Populating your website document root (p. 134)
• 7.3 Installing an SQL database (p. 134)
• Hardening SQL (p. 136)
• SQL administration (p. 137)
• 7.4 Installing PHP (p. 140)
• Installing PHP on Ubuntu (p. 140)
• Testing your PHP installation (p. 140)
• 7.5 Installing and configuring MediaWiki (p. 141)
• Troubleshooting missing extensions (p. 142)
• Connecting MediaWiki to the database (p. 145)
• 7.6 Installing the Apache web server on CentOS (p. 146)
• Understanding network ports (p. 147)
• Controlling network traffic (p. 148)
• Installing MariaDB on CentOS (p. 149)
• Installing PHP on CentOS (p. 149)
• 8 Networked file sharing: Building a Nextcloud file-sharing server (p. 155)
• 8.1 Enterprise file sharing and Nextcloud (p. 156)
• 8.2 Installing Nextcloud using snaps (p. 157)
• 8.3 Installing Nextcloud manually (p. 159)
• Hardware prerequisites (p. 159)
• Building a LAMP server (p. 161)
• Configuring Apache (p. 161)
• Downloading and unpacking Nextcloud (p. 163)
• 8.4 Nextcloud administration (p. 166)
• 8.5 Using AWS S3 as the primary Nextcloud storage (p. 169)
• 9 Securing your web server (p. 174)
• 9.1 The obvious stuff (p. 175)
• 9.2 Controlling network access (p. 177)
• Configuring a firewall (p. 177)
• Using nonstandard ports (p. 183)
• 9.3 Encrypting data in transit (p. 185)
• Preparing your website domain (p. 187)
• Generating certificates using Let's Encrypt (p. 187)
• 9.4 Hardening the authentication process (p. 189)
• Controlling file system objects with SELinux (p. 189)
• Installing and activating SELinux (p. 191)
• Applying SELinux policies (p. 193)
• System groups and the principle of least privilege (p. 194)
• Isolating processes within containers (p. 196)
• Scanning for dangerous user ID values (p. 197)
• 9.5 Auditing system resources (p. 197)
• Scanning for open ports (p. 198)
• Scanning for active services (p. 198)
• Searching for installed software (p. 199)
• 10 Securing network connections: Creating a VPN or DMZ (p. 203)
• 10.1 Building an OpenVPN tunnel (p. 204)
• Configuring an OpenVPN server (p. 205)
• Configuring an OpenVPN client (p. 212)
• Testing your VPN (p. 214)
• 10.2 Building intrusion-resistant networks (p. 215)
• Demilitarized zones (DMZs) (p. 216)
• Using iptables (p. 218)
• Creating a DMZ using iptables (p. 218)
• Creating a DMZ using Shorewall (p. 221)
• 10.3 Building a virtual network for infrastructure testing (p. 224)
• 11 System monitoring: Working with log files (p. 229)
• 11.1 Working with system logs (p. 230)
• Logging with journald (p. 231)
• Logging with syslogd (p. 233)
• 11.2 Managing log files (p. 235)
• The journald way (p. 235)
• The syslogd way (p. 236)
• 11.3 Consuming large files (p. 237)
• Using grep (p. 237)
• Using awk (p. 238)
• Using sed (p. 239)
• 11.4 Monitoring with intrusion detection (p. 241)
• Setting up a mail server (p. 241)
• Installing Tripwire (p. 242)
• Configuring Tripwire (p. 244)
• Generating a test Tripwire report (p. 247)
• 12 Sharing data over a private network (p. 251)
• 12.1 Sharing files through Network File System (NFS) (p. 252)
• Setting up the NFS server (p. 253)
• Setting up the client (p. 255)
• Mounting an NFS share at boot time (p. 256)
• NFS security (p. 257)
• 12.2 Sharing files with Windows users using Samba (p. 259)
• Testing your Samba configuration (p. 261)
• Accessing a Samba server from Windows (p. 262)
• 12.3 Sharing files with yourself using symbolic links (p. 262)
• 13 Troubleshooting system performance issues (p. 268)
• 13.1 CPU load problems (p. 269)
• Measuring CPU load (p. 269)
• Managing CPU load (p. 270)
• Making trouble (simulating CPU load) (p. 274)
• 13.2 Memory problems (p. 274)
• Assessing memory status (p. 274)
• Assessing swap status (p. 275)
• 13.3 Storage availability problems (p. 275)
• Inode limits (p. 276)
• The solution (p. 278)
• 13.4 Network load problems (p. 279)
• Measuring bandwidth (p. 279)
• Solutions (p. 280)
• Shaping network traffic with tc (p. 281)
• 13.5 Monitoring tools (p. 282)
• Aggregating monitoring data (p. 283)
• Visualizing your data (p. 284)
• 14 Troubleshooting network issues (p. 289)
• 14.1 Understanding TCP/IP addressing (p. 290)
• What's NAT addressing? (p. 290)
• Working with NAT addressing (p. 291)
• 14.2 Establishing network connectivity (p. 293)
• 14.3 Troubleshooting outbound connectivity (p. 295)
• Tracking down the status of your network (p. 295)
• Assigning IP addresses (p. 297)
• Configuring DNS service (p. 300)
• Plumbing (p. 302)
• 14.4 Troubleshooting inbound connectivity (p. 302)
• Internal connection scanning: netstat (p. 303)
• External connection scanning: netcat (p. 303)
• 15 Troubleshooting peripheral devices (p. 308)
• 15.1 Identifying attached devices (p. 309)
• 15.2 Managing peripherals with Linux kernel modules (p. 311)
• Finding kernel modules (p. 311)
• Manually loading kernel modules (p. 313)
• 15.3 Manually managing kernel parameters at boot time (p. 315)
• Passing parameters at boot time (p. 315)
• Passing parameters via the file system (p. 317)
• 15.4 Managing printers (p. 317)
• Basics of lp (p. 317)
• Managing printers using CUPS (p. 318)
• 16 DevOps tools: Deploying a scripted server environment using Ansible (p. 322)
• 16.1 What deployment orchestrators can do for you (p. 324)
• 16.2 Ansible: Installation and setup (p. 326)
• Setting up passwordless access to hosts (p. 326)
• Organizing Ansible hosts (p. 327)
• Testing connectivity (p. 328)
• 16.3 Authentication (p. 328)
• 16.4 Ansible playbooks (p. 330)
• Writing a simple playbook (p. 330)
• Creating multi-tiered, role-powered playbooks (p. 332)
• Managing passwords in Ansible (p. 334)
• Conclusion (p. 339)
• Appendix A chapter-by-chapter, command-line review (p. 343)
• Index (p. 351)

Author notes provided by Syndetics