دانلود کتاب Ubuntu Linux Bible

فهرست مطالب :

Cover
Title Page
Copyright Page
About the Authors
About the Technical Editor
Acknowledgments
Contents at a Glance
Contents
Introduction
How This Book Is Organized
Conventions Used in This Book
Jumping into Linux
How to Contact Wiley or the Authors
Part I Getting Started
Chapter 1 Starting with Linux
Understanding What Linux Is
Understanding How Linux Differs from Other Operating Systems
Exploring Linux History
Free-flowing UNIX culture at Bell Labs
Commercial UNIX
Berkeley Software Distribution arrives
UNIX Laboratory and commercialization
GNU transitions UNIX to freedom
BSD loses some steam
Linus builds the missing piece
OSI open source definition
Understanding How Linux Distributions Emerged
Understanding Red Hat
Understanding Ubuntu and other Debian distributions
Finding Professional Opportunities with Linux Today
Understanding how companies make money with Linux
Summary
Chapter 2 Creating the Perfect Linux Desktop
Understanding Linux Desktop Technology
Starting with the GNOME 3 Desktop Live Image
Using the GNOME 3 Desktop
After the computer boots up
Navigating with the mouse
Navigating with the keyboard
Setting up the GNOME 3 desktop
Extending the GNOME 3 desktop
Using GNOME shell extensions
Using the GNOME Tweak Tool
Starting with desktop applications
Managing files and folders with Nautilus
Installing and managing additional software
Playing music with Rhythmbox
Stopping the GNOME 3 desktop
Using the Unity Graphical Shell with the GNOME Desktop
Using the Metacity window manager
Changing GNOME’s appearance
Using the panels
Adding a drawer
Changing panel properties
Summary
Exercises
Part II Becoming a Linux Power User
Chapter 3 Using the Shell
About Shells and Terminal Windows
Using the shell prompt
Using a Terminal window
Using virtual consoles
Choosing Your Shell
Running Commands
Understanding command syntax
Locating commands
Recalling Commands Using Command History
Command-line editing
Command-line completion
Command-line recall
Connecting and Expanding Commands
Piping between commands
Sequential commands
Background commands
Expanding commands
Expanding arithmetic expressions
Expanding variables
Using Shell Variables
Creating and using aliases
Exiting the shell
Creating Your Shell Environment
Configuring your shell
Setting your prompt
Adding environment variables
Getting Information about Commands
Summary
Exercises
Chapter 4 Moving Around the Filesystem
Using Basic Filesystem Commands
Using Metacharacters and Operators
Using file-matching metacharacters
Using file-redirection metacharacters
Using brace expansion characters
Listing Files and Directories
Understanding File Permissions and Ownership
Changing permissions with chmod (numbers)
Changing permissions with chmod (letters)
Setting default file permission with umask
Changing file ownership
Moving, Copying, and Removing Files
Summary
Exercises
Chapter 5 Working with Text Files
Editing Files with Vim and Vi
Starting with vi
Adding text
Moving around in the text
Deleting, copying, and changing text
Pasting (putting) text
Repeating commands
Exiting vi
Skipping around in the file
Searching for text
Using ex mode
Learning more about vi and vim
Finding Files
Using locate to find files by name
Searching for files with find
Finding files by name
Finding files by user
Finding files by permission
Finding files by date and time
Using “not” and “or” when finding files
Finding files and executing commands
Searching in files with grep
Summary
Exercises
Chapter 6 Managing Running Processes
Understanding Processes
Listing Processes
Listing processes with ps
Listing and changing processes with top
Listing processes with System Monitor
Managing Background and Foreground Processes
Starting background processes
Using foreground and background commands
Killing and Renicing Processes
Killing processes with kill and killall
Using kill to signal processes by PID
Using killall to signal processes by name
Setting processor priority with nice and renice
Limiting Processes with cgroups
Summary
Exercises
Chapter 7 Writing Simple Shell Scripts
Understanding Shell Scripts
Executing and debugging shell scripts
Understanding shell variables
Special shell positional parameters
Reading in parameters
Parameter expansion in Bash
Performing arithmetic in shell scripts
Using programming constructs in shell scripts
The “if. . .then” statements
The case command
The “for. . .do” loop
The “while. . .do” and “until. . .do” loops
Trying some useful text manipulation programs
The global regular expression print
Remove sections of lines of text (cut)
Translate or delete characters (tr)
The stream editor (sed)
Using simple shell scripts
Telephone list
Backup script
Summary
Exercises
Part III Becoming a Linux System Administrator
Chapter 8 Learning System Administration
Understanding System Administration
Using Graphical Administration Tools
Using Cockpit browser-based administration
Using other browser-based admin tools
Invoking Administration Privileges
Becoming root from the shell
Gaining temporary admin access with sudo
Exploring Administrative Commands, Configuration Files, and Log Files
Administrative commands
Administrative configuration files
Administrative log files and systemd journal
Using journalctl to view the systemd journal
Managing log messages with rsyslogd
Using Other Administrative Accounts
Checking and Configuring Hardware
Checking your hardware
Managing removable hardware
Working with loadable modules
Listing loaded modules
Loading modules
Removing modules
Summary
Exercises
Chapter 9 Installing Linux
Choosing a Computer
Installing Ubuntu Desktop
Installing Ubuntu Server
Understanding Cloud-Based Installations
Installing Linux in the Enterprise
Exploring Common Installation Topics
Upgrading or installing from scratch
Dual booting
Installing Linux to run virtually
Using installation boot options
Boot options for disabling features
Boot options for video problems
Boot options for special installation types
Using specialized storage
Partitioning hard drives
Understanding different partition types
Tips for creating partitions
Using the GRUB 2 boot loader
Summary
Exercises
Chapter 10 Getting and Managing Software
Managing Software on the Desktop
Going Beyond the Software Window
Understanding Linux Software Packaging
Working with Debian Packaging
APT basics
Working with APT repositories
Working with dpkg
Summary
Exercises
Chapter 11 Managing User Accounts
Creating User Accounts
Adding users with adduser
Setting user defaults
Modifying users with usermod
Deleting users with deluser
Understanding Group Accounts
Using group accounts
Creating group accounts
Managing Users in the Enterprise
Setting permissions with Access Control Lists
Setting ACLs with setfacl
Setting default ACLs
Enabling ACLs
Adding directories for users to collaborate
Creating group collaboration directories (set GID bit)
Creating restricted deletion directories (sticky bit)
Centralizing User Accounts
Summary
Exercises
Chapter 12 Managing Disks and Filesystems
Understanding Disk Storage
Partitioning Hard Disks
Understanding partition tables
Viewing disk partitions
Creating a single-partition disk
Creating a multiple-partition disk
Using Logical Volume Manager Partitions
Checking an existing LVM
Creating LVM logical volumes
Growing LVM logical volumes
Mounting Filesystems
Supported filesystems
Enabling swap areas
Disabling swap area
Using the fstab file to define mountable filesystems
Using the mount command to mount filesystems
Mounting a disk image in loopback
Using the umount command
Using the mkfs Command to Create a Filesystem
Managing Storage with Cockpit
Summary
Exercises
Part IV Becoming a Linux Server Administrator
Chapter 13 Understanding Server Administration
Getting Started with Server Administration
Step 1: Install the server
Step 2: Configure the server
Using configuration files
Checking the default configuration
Step 3: Start the server
Step 4: Secure the server
Password protection
Firewalls
TCP Wrappers
AppArmor
Security settings in configuration files
Step 5: Monitor the server
Configure logging
Run system activity reports
Watch activity live with Cockpit
Keep system software up to date
Check the filesystem for signs of crackers
Checking and Setting Servers
Managing Remote Access with the Secure Shell Service
Starting the openssh-server service
Using SSH client tools
Using ssh for remote login
Using SSH for remote execution
Copying files between systems with scp and rsync
Interactive copying with sftp
Using key-based (passwordless) authentication
Configuring System Logging
Enabling system logging with rsyslog
Understanding the rsyslog.conf file
Understanding log messages
Setting up and using a loghost with rsyslogd
Watching logs with logwatch
Checking System Resources with sar
Checking System Space
Displaying system space with df
Checking disk usage with du
Finding disk consumption with find
Managing Servers in the Enterprise
Summary
Exercises
Chapter 14 Administering Networking
Configuring Networking for Desktops
Checking your network interfaces
Checking your network from NetworkManager
Checking your network from Cockpit
Checking your network from the command line
Configuring network interfaces
Setting IP addresses manually
Setting IP address aliases
Setting routes
Configuring a network proxy connection
Configuring Networking from the Command Line
Configure networking with nmtui
Editing a NetworkManager TUI connection
Understanding networking configuration files
Other networking files
Setting alias network interfaces
Setting up Ethernet channel bonding
Setting custom routes
Configuring Networking in the Enterprise
Configuring Linux as a router
Configuring Linux as a DHCP server
Configuring Linux as a DNS server
Configuring Linux as a proxy server
Summary
Exercises
Chapter 15 Starting and Stopping Services
Understanding the Initialization Daemon (init or systemd)
Understanding the classic init daemons
Understanding systemd initialization
Learning systemd basics
Learning systemd’s backward compatibility to SysVinit
Checking the Status of Services
Checking services for SysVinit systems
Stopping and Starting Services
Stopping and starting SysVinit services
Stopping a service with systemd
Starting a service with systemd
Restarting a service with systemd
Reloading a service with systemd
Enabling Persistent Services
Configuring persistent services for SysVinit
Enabling a service with systemd
Disabling a service with systemd
Configuring a Default Runlevel or Target Unit
Configuring the SysVinit default runlevel
Adding New or Customized Services
Adding new services to SysVinit
Step 1: Create a new or customized service script file
Step 2: Add the service script to /etc/rc.d/init.d
Step 3: Set appropriate permission on the script
Step 4: Add the service to runlevel directories
Adding new services to systemd
Step 1: Create a new or customized service configuration unit file
Step 2: Move the service configuration unit file
Step 3: Add the service to the Wants directory
Summary
Exercises
Chapter 16 Configuring a Print Server
Common UNIX Printing System
Setting Up Printers
Adding a printer automatically
Using web-based CUPS administration
Allow remote printing administration
Add a printer not automatically detected
Using the Print Settings window
Configuring local printers with the Print Settings window
Configuring remote printers
Adding a remote CUPS printer
Adding a remote UNIX (LDP/LPR) printer
Adding a Windows (SMB) printer
Working with CUPS Printing
Configuring the CUPS server (cupsd.conf)
Starting the CUPS server
Configuring CUPS printer options manually
Using Printing Commands
Printing with lp
Listing status with lpstat -t
Removing print jobs with cancel
Configuring Print Servers
Configuring a shared CUPS printer
Configuring a shared Samba printer
Understanding smb.conf for printing
Setting up SMB clients
Summary
Exercises
Chapter 17 Configuring a Web Server
Understanding the Apache Web Server
Getting and Installing Your Apache Web Server
Controlling Apache
Securing Apache
Apache file permissions and ownership
Apache and firewalls
Apache and AppArmor
Understanding the Apache configuration files
Using directives
Understanding default settings
Adding a virtual host to Apache
Allowing users to publish their own web content
Securing your web traffic with TLS
Understanding how SSL is configured
Generating an SSL key and self-signed certificate
Generating a certificate signing request
Troubleshooting Your Web Server
Checking for configuration errors
Access forbidden and server internal errors
Summary
Exercises
Chapter 18 Configuring an FTP Server
Understanding FTP
Installing the vsftpd FTP Server
Controlling the vsftpd Service
Securing your FTP server
Integrating Linux file permissions with vsftpd
Configuring Your FTP Server
Setting up user access
Allowing uploading
Setting up vsftpd for the Internet
Using FTP Clients to Connect to Your Server
Accessing an FTP server from a browser
Accessing an FTP server with the lftp command
Using the gFTP client
Summary
Exercises
Chapter 19 Configuring a Windows File Sharing (Samba) Server
Understanding Samba
Installing Samba
Controlling Samba
Viewing Samba processes
Configuring Samba
Configuring the [global] section
Configuring the [homes] section
Configuring the [printers] section
Creating a Samba shared folder
Checking the Samba share
Accessing Samba Shares
Accessing Samba shares in Linux
Accessing Samba shares from a Linux file manager
Mounting a Samba share from a Linux command line
Accessing Samba shares in Windows
Using Samba in the Enterprise
Summary
Exercises
Chapter 20 Configuring an NFS File Server
Installing an NFS Server
Starting the NFS Service
Sharing NFS Filesystems
Configuring the /etc/exports file
Hostnames in /etc/exports
Access options in /etc/exports
User mapping options in /etc/exports
Exporting the shared filesystems
Securing Your NFS Server
Using NFS Filesystems
Viewing NFS shares
Manually mounting an NFS filesystem
Mounting an NFS filesystem at boot time
Mounting noauto filesystems
Using mount options
Using autofs to mount NFS filesystems on demand
Automounting to the /net directory
Automounting home directories
Unmounting NFS Filesystems
Summary
Exercises
Chapter 21 Troubleshooting Linux
Boot-Up Troubleshooting
Understanding startup
Starting from the firmware (BIOS or UEFI)
Troubleshooting BIOS setup
Troubleshooting boot order
GRUB 2 boot loader
Starting the kernel
Troubleshooting the initialization system
Troubleshooting Software Packages
Troubleshooting Networking
Troubleshooting outgoing connections
View network interfaces
Check physical connections
Check routes
Check hostname resolution
Troubleshooting incoming connections
Check if the client can reach your system at all
Check if the service is available to the client
Check the service on the server
Troubleshooting Memory
Uncovering memory issues
Checking for memory problems
Dealing with memory problems
Summary
Exercises
Part V Learning Linux Security Techniques
Chapter 22 Understanding Basic Linux Security
Implementing Physical Security
Implementing disaster recovery
Securing user accounts
One user per user account
Limiting access to the root user account
Setting expiration dates on temporary accounts
Removing unused user accounts
Securing passwords
Choosing good passwords
Setting and changing passwords
Enforcing best password practices
Understanding the password files and password hashes
Securing the filesystem
Managing dangerous filesystem permissions
Securing the password files
Locking down the filesystem
Managing software and services
Updating software packages
Keeping up with security advisories
Advanced implementation
Monitoring Your Systems
Monitoring log files
Monitoring user accounts
Detecting counterfeit accounts and privileges
Detecting bad account passwords
Monitoring the filesystem
Verifying software packages
Scanning the filesystem
Detecting viruses and rootkits
Auditing and Reviewing Linux
Conducting compliance reviews
Conducting security reviews
Summary
Exercises
Chapter 23 Understanding Advanced Linux Security
Implementing Linux Security with Cryptography
Understanding hashing
Understanding encryption/decryption
Understanding cryptographic ciphers
Understanding cryptographic cipher keys
Understanding digital signatures
Implementing Linux cryptography
Ensuring file integrity
Encrypting a Linux filesystem at installation
Encrypting a Linux directory
Encrypting a Linux file
Encrypting Linux with miscellaneous tools
Using Encryption from the Desktop
Implementing Linux Security with PAM
Understanding the PAM authentication process
Understanding PAM contexts
Understanding PAM control flags
Understanding PAM modules
Understanding PAM system event configuration files
Administering PAM on your Linux system
Managing PAM-aware application configuration files
Implementing resources limits with PAM
Implementing time restrictions with PAM
Enforcing good passwords with PAM
Encouraging sudo use with PAM
Obtaining more information on PAM
Summary
Exercises
Chapter 24 Enhancing Linux Security with AppArmor
Understanding AppArmor
Working with AppArmor
Summary
Exercises
Chapter 25 Securing Linux on a Network
Auditing Network Services
Evaluating access to network services with nmap
Using nmap to audit your network services’ advertisements
Working with Firewalls
Understanding firewalls
Implementing firewalls
Starting with UFW
Understanding the iptables utility
Using the iptables utility
Summary
Exercises
Part VI Engaging with Cloud Computing
Chapter 26 Shifting to Clouds and Containers
Understanding Linux Containers
Namespaces
Container registries
Base images and layers
Working with Linux Containers
Deploying LXD containers
Deploying Docker containers
Using containers in the enterprise
Summary
Exercises
Chapter 27 Deploying Linux to the Public Cloud
Running Linux in the Cloud Using cloud-init
Creating LXD Linux Images for Cloud Deployments
Working with LXD profiles
Working with LXD images
Using OpenStack to deploy cloud images
Using Amazon EC2 to Deploy Cloud Images
Installing the AWS CLI
Provisioning and launching an EC2 instance
Summary
Exercises
Chapter 28 Automating Apps and Infrastructure with Ansible
Understanding Ansible
Exploring Ansible Components
Inventories
Playbooks
Plays
Tasks
Modules
Roles, imports, and includes
Stepping Through an Ansible Deployment
Prerequisites
Setting up SSH keys to each node
Installing Ansible
Creating an inventory
Authenticating to the hosts
Creating a playbook
Run the playbook
Running Ad-Hoc Ansible Commands
Trying ad-hoc commands
Summary
Exercises
Chapter 29 Deploying Applications as Containers with Kubernetes
Understanding Kubernetes
Kubernetes masters
Kubernetes workers
Kubernetes applications
Kubernetes interfaces
Trying Kubernetes
Getting Kubernetes up and running
Deploying a Kubernetes application
Getting information on the deployment’s pods
Exposing applications with services
Scaling up an application
Checking the load balancer
Scaling down an application
Deleting a service
Summary
Exercises
Appendix: Exercise Answers
Index
EULA