Linux入门详解

Linux基础知识

Linux&Unix

　　 说起Linux，就不得不提Unix操作系统。

　　 Unix系统号称世界上最稳定的系统，就连苹果公司也从中获取灵感开发出了移动端大名鼎鼎的IOS。

　　 Unix操作系统有一个特点即为多用户多任务，同一时刻允许多个用户同时使用该系统且互不干扰。

　　 Linux的全称为GNU/Linux，内核于1991年10月5日首次发布，是基于Unix系统开发而来的。

　　 它的基本思想是一切皆文件，其描述如下：

　　 每个文件都有确定的用途。其中第一条详细来讲就是系统中的所有都归结为一个文件，包括命令、硬件和软件设备、操作系统、进程等等对于操作系统内核而言，都被视为拥有各自特性或类型的文件。

　　 Linux全称中的GNU也是一个可以聊的点，GNU是一个项目，由Richard Stallman在1983年9月27日公开发起，它的目标就是创建一套完全自由的操作系统，在其中有一条GPL条款，该条款大体思想如下：

　　 可以自由的使用，复制，修改，发布GNU项目下的软件。

　　 所有GNU软件都有一份在进制其他人添加任何限制的情况下授予所有权利给任何人的协议条款。

　　 1.你有自由以任何目的来运行该程序

　　 2.你有修改程序满足自己需求的自由

　　 3.你有权利重新发布副本，既可以白送也可以收取一定的费用

　　 4.你有权利发布该程序修改过的版本，从而让其他人得益于你的改进

　　 所以Linux其源代码完全开源，历经这么多年的沉淀已经非常优秀，大量的程序员对研究它乐此不疲。

　　

Os&Kernel&系统调用接口

　　 Os即为操作系统的意思，操作系统是一个用来协调，管控计算机硬件和软件资源的系统程序。它位于硬件和应用程序之间。

　　 每个操作系统都有一个内核Kernel，它是为应用程序提供对计算机硬件安全访问的一个软件，负责所有的物理资源。包括：文件系统，内存管理，设备管理和进程管理。

　　 因此我们一般将计算机分为三层：

　　

　　 一个应用软件如果想操纵底层硬件，必须经过系统调用接口发起系统调用，再由系统调用操纵内核，最后经内核帮助调用底层的系统硬件。

　　

　　 所以说操作系统的调用接口是服务于应用层面的软件的，但其本身属于操作系统这一层。

　　 在内核进行操纵硬件时，实际上会切换CPU状态，内核态与用户态，详情参见： 计算机基础

镜像安装

　　 Linux下有很多发行版本，如最近大火的UOS常年霸占新闻头条，除此之外还有CENTOS（企业级）, RHEL（红帽）, FEDORA, UBUNTU（乌班图）, SUSE等...

　　 在这里我将采用CentOs7.3进行展示，其实各大发行版本的命令大差不差，可以说一通百通。

　　 Windows环境下可采用虚拟机的方式进行安装，这里我将采用vmware workstation：

　　 点击进行下载Vmware workstation：版本（16.1.0），激活密钥：

ZF3R0-FHED2-M80TY-8QYGC-NPKYF

　　 在下载虚拟机时，同时下载Centos7.3：

　　 点击进行下载Centos 7.3 iso：

　　

　　 这里将不演示Vmware的安装，一路点击下一步即可。

　　 安装Centos镜像：

　　

　　

　　

　　

　　

　　

　　

　　

　　

　　

　　

　　

　　

Centos安装

　　

　　

　　

内存最低要求：512MB

时区选择  亚洲中国上海
键盘选择  美式标准键盘

带GUI的服务器（请勿选择最小安装）

创建普通用户与ROOT密码（如果密码强度不够，按两次done）

BOOT：引导分区 一般给 500M 内核

SWAP：虚拟内存 一般给物理内存的1.5倍至2.0倍（一般不超过8GB）  作用是缓解内存的压力临时存放数据

/：根目录，类似于Windows 的C:\\ D:\\ E:\\ F:\\ 这些盘符概念。实际就叫根目录

CentOS 默认最小安装：可以手动选择一些自带的软件

在成功安装后如果提示：没有足够的内存自动启用 kdump，请使用system-config-kdump手动配置
出现这样的信息。意思是说系统意外崩溃之后，kdump程序就负责将内核操作系统的状态备份下来。

基本介绍

Terminal

　　 在桌面上单击鼠标右键，选择Open Terminal打开第一个终端。

　　 也可以使用CTRL + SHIFT + N开启一个新的终端（当前终端已打开）。

　　 Linux终端又叫虚拟控制台，Linux终端采用字符命令行方式工作，用户通过键盘输入命令，通过Linux终端对系统进行控制

　　

　　 Linux下可以开启多个终端，使用CTRL + ALT + [ F1-F6 ]进行终端的切换。

　　 当用户登录完成后会有提示符信息，如上图所示以普通用户登录系统后的提示符为$，如果使用root用户进行登录，提示符为#

# 普通用户
[yunya@localhost ~]$  

# root用户
[root@localhost yunya]#

　　 使用exit命令退出终端。

　　 使用tab键进行命令补全。

命令演示

　　 在Linux中命令语法格式为：命令 [选项] [参数]。

　　

　　 命令：要求Linux（Unix）执行的指令

　　 选项：用来修饰命令，告诉命令具体怎么样去执行（也可以改变命令）。部分是以‘-’字符开头的。

　　 参数：参数就是说命令影响（操作）的是什么（比如一个文件，一个视频等等 ls -a/）

　　

　　 基本命令

　　 使用init 0关闭当前Linux系统。

　　 使用clear命令或者快捷键CTRL + R进行清屏。

　　 使用CTRL + C对一条正在执行的命令进行中止。

　　 查看帮助：man [命令]

　　 查看帮助：命令 --help

　　 查看历史命令记录：history

　　 目录查看

　　 使用ls命令进行目录浏览。

　　 命令选项-l查看详细信息。

　　 命令选项-a查看隐藏目录。

　　 如下所示，浏览根目录下的详细信息：

[root@localhost yunya]# ls -l /

　　

　　 用户相关

　　 使用who命令，列出目前该系统上工作的用户：

[root@localhost yunya]# who
yunya    :0           2021-01-28 13:18 (:0)
yunya    pts/0        2021-01-28 13:32 (:0)
yunya    tty2         2021-01-28 13:29
root     tty3         2021-01-28 13:31

　　 使用whoami命令，显示自身用户的名称：

[root@localhost yunya]# whoami
root

　　 使用useradd [username]新建用户。

　　 使用passwd [username]修改指定用户的密码，如果不加选项[username]，则默认清楚当前用户的密码。

　　 从当前用户切换到另一个用户，命令su [username]

　　 如下示例，使用su root命令切换至Root用户，会提示你进行输入密码。（首次输入密码即相当于设置密码）

# 密码是隐藏的
[yunya@localhost ~]$ su root
Password:
# 登录成功
[root@localhost yunya]#

　　

　　 日期相关

　　 使用date命令查看日期：

[root@localhost yunya]# date
Thu Jan 28 13:44:29 PST 2021

　　 如果想设置日期，格式为：date '月日时分年'，需要root权限：

[root@localhost yunya]# date '120112002011'
Thu Dec  1 12:00:00 PST 2011

　　 使用hwcclock -s命令同步硬件时间：

[root@localhost yunya]# hwclock -s
[root@localhost yunya]# date
Thu Jan 28 13:51:49 PST 2021

　　 使用cal查看万年历：

[root@localhost yunya]# cal
    January 2021
Su Mo Tu We Th Fr Sa
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

基础操作篇

目录结构

　　 在Linux或Unix操作系统中，所有的文件和目录都被组织成一个以根/节点开始的倒置的树状结构。

　　 Linux中的目录相当于Windows中的文件夹，目录中存放的既可以是文件也可以是其他子目录。

　　 Linux下的顶层目录用/来表示，俗称为根目录。在Linux下只能有一个，而Windows下可以有多个，相当于C:\\ D:\\这样的盘符概念。

　　 使用.代表当前目录，即用户工作的工作目录。

　　 使用..代表上层目录，即当前目录的上一层目录。

　　 使用*表示选中所有文件及目录，如/*。

重要目录

　　 使用ls /可查看根目录下的目录和文件，其中有一些重要的目录：

[root@localhost yunya]# ls /
bin   dev  home  lib64  mnt  proc  run   srv  tmp  var
boot  etc  lib   media  opt  root  sbin  sys  usr

　　 Linux下重要目录解释：

目录名称	描述	使用方向
/bin	存放常用的可执行文件binary二进制的可执行文件	不推荐随意使用
/sbin	存放系统的可执行文件super binary系统的命令	不推荐随意使用
/usr	存放常用的可执行文件binary二进制的可执行文件	随便用
/dev	设备文件目录，存放linux系统下的设备文件，访问该目录下某个文件，相当于访问某个设备	不推荐随意使用
/home	家目录，root用户家目录为/root，普通用户家目录都存放在/home目录下，使用用户名作家目录下的名称，如用户名yunya的家目录则存放在/home/yunya，另外使用~代表当前用户的家目录	随便用
/mnt	挂载点目录，通常可移除式硬件会挂载在此目录或/media目录下	随便用
/media	挂载点目录，通常可移除式硬件会挂载在此目录或/mnt目录下	随便用
/proc	此目录的数据都在内存中，如系统核心，外部设备，网络状态，由于数据都存放于内存中，所以不占用磁盘空间	不推荐随意使用
/srv	服务启动之后需要访问的数据目录，如www服务需要访问的网页数据存放在/srv/www内	不推荐随意使用
/etc	配置文件目录，不建议在此目录下存放可执行文件	不推荐随意使用
/tmp	临时文件存放目录	类似于Windows中的回收站，推荐将暂时不用的文件存放至此
/var	放置系统执行过程中经常变化的文件	不推荐随意使用
/boot	放置linux系统启动时用到的一些文件	不推荐随意使用
/lib	系统使用的函数库的目录，程序在执行过程中，需要调用一些额外的参数时需要函数库的协助，比较重要的目录为/lib/modules。	不推荐随意使用
/opt	给主机额外安装软件所摆放的目录，但是一般情况下下载的软件都会存放在/usr/local目录下	随便用

重要命令演示

　　 工作目录

　　 使用pwd命令展示当前的工作目录

　　

　　 切换目录

命令	描述
cd	返回家目录，也可使用cd ~产生相同效果（root用户回到/root下，普通用户回到/home/username下）
cd [路径]	进入某个目录
cd ..	返回上级目录
cd -	返回上一次所在的目录中

　　 ls命令

命令	描述
ls	查看当前目录下的文件及目录
ls -l	查看当前目录下的文件及目录的详细信息，可简写为ll
ls -d	查看当前目录下的子目录，如加上-l参数，则为查看目录的详细信息
ls -a	查看当前目录下的显示文件/隐藏文件/显示目录/隐藏目录
ls [选项] [路径参数]	根据选项查看某一目录下的文件及目录

　　

　　 查看目录大小

命令	描述
du -sh [目录名]	查看目录大小

　　 查看文件

命令	描述
cat [目标文件路径]	查看文本文件全部内容
head [行数] [目标文件路径]	查看文本文件内容（默认头十行） -1 显示一行
tail [行数] [目标文件路径]	查看文本文件内容（默认尾部十行）
tail -f [目标文件路径]	查看文本文件内容，并动态监测文本变化（文本有文件更新立马返回）
more [目标文件路径]	查看文本文件内容，根据屏幕占比百分比显示
less [目标文件路径]	查看文本文件内容，使用上下键来翻页文档

　　 复制和剪切

命令	描述
cp [原文件路径] [目标文件路径]	拷贝文件到目标目录中，如果目标文件路径不存在，则创建
cp -r [目录] [目标文件路径]	递归的拷贝目录下的子目录及文件至模板目标文件路径，如果目标文件路径不存在，则创建
mv [原文件路径] [目标文件路径]	剪切文件到目标目录中，如果目标文件路径不存在，则创建

　　 注意：mv命令可用于重命名，如原文件路径和目标文件路径相同，则相当于重命名操作

　　 创建目录/文件

命令	描述
touch [目标文件路径]	新建文件到目标文件路径中
mkdir [目录名]	创建一个空目录
mkdir [目录名1/目录名2/目录名3]	创建一串空目录

　　 rm命令

命令	描述
rm [目标文件]	删除指定文件，并弹出提示
rm -f [目标文件]	删除指定文件，不弹出提示
rm -rf [目标目录]	删除一个目录树。包括所有文件，并且不提示（rm -rf /*万恶之源删库跑路）

管道符过滤

　　 |管道符

　　 管道符的作用就是将一系列操作交由下一个命令继续操作。待所有命令处理完后再打印出来。

　　 grep

　　 grep命令是过滤命令，使用正则进行过滤。

　　 通常与管道符进行配合使用，如下所示：

# 查看home目录下所有项目
[root@localhost ~]# ls /home
Jack  ken  NewUser  yunya

# 查看home目录下以J或者k开头的项目名
[root@localhost ~]# ls /home | grep '^[Jk]'
Jack
ken

# 使用grep -v进行反向过滤
# 查看home目录下不以J或者k开头的项目名
[root@localhost ~]# ls /home | grep -v '^[Jk]'
NewUser
yunya

　　 head

　　 head命令可以从头部提取几条信息进行查看。

　　 除了在读取文本的时候直接使用，也可以和管道符进行连接配合其他命令使用：

# 只查看home目录下的第一个项目
[root@localhost ~]# ls /home | head -1
Jack

　　 tail

　　 tail命令可以从底部提取几条信息进行查看。

　　 除了在读取文本的时候直接使用，也可以和管道符进行连接配合其他命令使用：

# 只查看home目录下的最后一个项目
[root@localhost ~]# ls /home | tail -1
yunya

alias内建命令

　　 在Linux操作系统中，所有的命令都是有一些默认参数。

　　 要么在/bin目录下，要么在/sbin目录下。

　　 alias命令（注意全为小写）的功能是设置命令的别名，以简写命令，提高操作效率。根据参数的不同，该命令可查看已设定的别名，或为命令设置新的别名。

　　 比如cp里面有个-i的参数，它的作用是在于如果你复制文件时目标路径拥有相同文件，会提示你是否去覆盖，但是我们调用的时候并没有加 -i 参数，却还是有这样的提醒。那就说明系统把 cp -i给alisa成了 cp了。

copy的原理

　　 操作系统中的copy底层实际原理其实就是在copy的目标目录建立一个和被copy文件同名的文件。

　　 再将被copy文件中的内容读取出来再写入到被拷贝文件的拷贝目标目录中的同名文件里。这就完成了一次copy。

　　

　　 step01:打开被copy的文件，加载内容至内存中

　　 step02:在拷贝的目标目录中创建同名文件

　　 step03:将内存中存放的被copy文件数据写入至同名文件中

　　 step04:删除原目录下被copy的文件

用户与群组篇

用户信息文件

　　 Linux下一切皆文件，当使用useradd命令新建一个用户的话，其实内部也会发生一些变化。

　　 举例，当我们使用新建名创建出NewUser后，变化如下：

[yunya@localhost /]$ su root
Password:
[root@localhost /]# useradd NewUser

　　 1.用户信息文件：/etc/passwd

　　 截取最后两行内容：

yunya:x:1000:1000:yunya:/home/yunya:/bin/bash
NewUser:x:1001:1001::/home/NewUser:/bin/bash

　　 在此文件中，每一行代表一个用户的信息。并且以冒号为分隔符，将一行信息分为七段。

　　 第一段：用户名

　　 第二段：密码占位符

　　 第三段：UID（user id），即用户识别码，系统管理员是0，1-999为系统用户，1000-65535为普通用户

　　 第四段：GID，(group id)，即用户组识别码，不同的用户可以属于同一个组，并且享有该组的共同权限

　　 第五段：COMMENT账号描述信息（随便写）

　　 第六段：家目录路径，普通用户在/home下，而root用户在/root下

　　 第七段：这一段是一个可执行文件的路径，如果该段内容是/bin/bash则说明该用户可以登录该系统，而如果是在/sbin/nologin下面则说明该用户不可以登录该系统

　　 2.用户密码文件：/etc/shadow

　　 截取最后两行内容：

yunya:$1$Af9h4qoA$6AkEHGBWgQjC1RGGAAFRp/:18655:0:99999:7:::
NewUser:!!:18657:0:99999:7:::

　　 第一段：用户名

　　 第二段：经过加密的密码

　　 后面所有部分为过期时间，过期时的提示信息等

　　

　　 3.组文件：/etc/group

　　 截取最后两行内容：

yunya:x:1000:yunya
NewUser:x:1001:NewUser

　　 第一段：组名，组名默认为用户名，可以说一个用户就是一个组

　　 第二段：组密码占位符，其真实密码是存放在/etc/gshadow中

　　 第三段：组ID，具有唯一性

　　 第四段：组默认成员，默认的组成员就只有自己

　　 4.组密码文件：/etc/gshadow

yunya:!::
NewUser:!::

　　 5.用户家目录：/home/userName

[root@localhost /]# ls /home
NewUser  yunya

　　 6.用户邮箱：/var/spool/mail

[root@localhost /]# ls /var/spool/mail
NewUser  root  rpc  yunya

　　 在了解完上述内容之后，我们发现其实useradd这条命令就是修改了这一系列文件，那么我们其实也可以手动的修改文件内容达到新增用户的目的。

　　 第一步：编辑基本用户信息，vim /etc/passwd打开该文件，按下G跳转到最后一行，按下o进行编辑，写入以下内容后按下ESC键进入命令模式，按下:进入扩展模式，输入wq!进行保存退出。

ken:x:1002:1002:this is test user:/home/ken:/bin/bash

　　 第二步：编辑用户密码相关，vim /etc/shadow，重复上述步骤，写入内容如下：

ken:!::ken

　　 第三步：编辑用户组相关，vim /etc/group，重复上述步骤，写入内容如下：

ken:x:1002:ken

　　 第四步：编辑用户组密码相关，vim /etc/gshadow，重复上述步骤，写入步骤如下：

ken:!::

　　 第五步 ：创建用户家目录，命令如下：

[root@localhost /]# mkdir /home/ken
[root@localhost /]# cp -r /etc/skel/.[!.]* /home/ken
[root@localhost /]# ls -a /home/ken
.  ..  .bash_logout  .bash_profile  .bashrc  .mozilla

　　 第六步：创建用户邮箱文件，命令如下：

[root@localhost /]# touch /var/spool/mail/ken

　　 尝试使用su命令进行切换账户：

[root@localhost /]# su ken
[ken@localhost /]$ cd ~
[ken@localhost ~]$

用户相关命令

　　 查看用户id

　　 你可以使用id userName的方式来查看某一用户的ID。

　　

　　 useradd命令

命令/选项	描述
useradd [选项] [用户名]	使用默认方式创建新用户
选项：-u	指定用户的uid
选项：-g	指定用户所属的群组
选项：-d	指定用户的家目录
选项：-c	指定用户的备注信息
选项：-s	指定用户所用的shell（是否可登录）
选项：-G	指定用户所属的附加组

　　 命令演示：

[root@localhost /]# useradd -u1003 -gken -d/home/Jack -cJack -s/bin/bash Jack
[root@localhost /]# su Jack
[Jack@localhost /]$
创建用户id是1003，群组为ken的群组，家目录为/home/Jack,账号描述信息是Jack，登录状态是允许登录，用户名是Jack

　　 userdel命令

命令	描述
userdel -r [用户名]	删除用户，一定要带上参数-r，否则将会失败

　　 命令演示：

[root@localhost /]# userdel Jack

　　 usermod命令

命令/选项	描述
usermod [选项] [用户名]	修改现有的用户相关信息及权限
选项：-u	修改用户UID
选项：-g	修改用户所属的GID
选项：-d	修改用户的家目录（如果家目录修改，无法通过su切换该用户）
选项：-c	修改用户的备注信息
选项：-s	修改用户所用的shell（登录状态）
选项：-G	将用户所在的组加入到另一个指定的组
选项：-L	锁定用户，不能登录
选项：-U	解锁用户，可以登录
选项：-o	一般与-g选项同时使用，表示新用户组的GID可以与系统已有用户组的GID相同

　　 命令演示：

[root@localhost /]# id NewUser
uid=1001(NewUser) gid=1001(NewUser) groups=1001(NewUser)
[root@localhost /]# usermod -u1020 -gyunya -cnew_user_message NewUser
[root@localhost /]# id NewUser
uid=1020(NewUser) gid=1000(yunya) groups=1000(yunya)
[root@localhost /]#

　　 passwd命令

命令/选项	描述
passwd [选项] [用户名]	如果选项为空，则修改用户密码
选项：-l	锁定口令，即禁用该用户
选项：-u	解锁口令，即接出该用户的禁用状态
选项：-d	使该账号无口令
选项：-f	强迫用户下次登陆时修改口令

群组相关命令

　　 grounpmod命令

命令/选项	描述
grounpmod [选项] [群组名]	修改现有的组名相关信息及权限
选项：-g	修改群组的GID
选项：-n	修改群组的名称
选项：-G	将用户加入到一个指定的组中
选项：-L	锁定群组，该群组下的用户将不能登录
选项：-U	解锁群组，该群组下的用户将可以登录

　　 groupdel命令

命令	描述
grounpmod [群组名]	删除一个已有的群组

权限相关篇

文件权限操作

　　 使用命令ll可查看一个文件的详细信息，如下所示：

[root@localhost ~]# touch test
[root@localhost ~]# ll test
-rw-r--r--. 1 root root 0 Jan 30 05:19 test

　　 -rw-r--r--属于文件权限信息，1是连接数，第一个root是创建者（属主），第二个root是创建者所属的群组（属组），后面的信息是文件展位字节大小与时间。

　　 对于权限信息来说，它分为10个部分：

　　 第一部分：第1位置，-是普通文件，d是目录文件，b是块文件，p是管道文件，l是软链接

　　 第二部分：第2、3、4位，代表属主的权限，-是无权限，r是读权限，w是写权限，x是可执行权限

　　 第三部分：第5、6、7位，代表属组的权限，-是无权限，r是读权限，w是写权限，x是可执行权限

　　 第四部分：第8、9、10位，代表其他用户的权限（即除了root和属主之外的用户权限），-是无权限，r是读权限，w是写权限，x是可执行权限

　　 另外，root权限用户高于其他所有，不可对其进行限制

　　 执行可执行文件

　　 如果具有x权限，代表该文件可执行，执行方式如下：

# 方式1
sh [文件名]

# 方式2
./ [文件名]

　　 权限修改命令chmod

　　 修改文件权限的命令是chmod，分别有在原有基础上的 +-权限方法，如原本只有 r--则可以修改成 +xw 就成了 rxw 了。还有一种就是 = 赋值法，清除原有权限，赋予新的权限。

　　 chmod uga=（取消全部权限）-（只用输入一个） 用a可以直接等同于 uga= 的操作

　　 u是属主，g是属组，o是其他用户，a是全部

# 取消所有权限
[root@localhost ~]# chmod uga= test
[root@localhost ~]# ll test
----------. 1 root root 0 Jan 30 05:19 test

# 取消所有权限
[root@localhost ~]# chmod a= test
[root@localhost ~]# ll test
----------. 1 root root 0 Jan 30 05:19 test

# 增加所有权限
[root@localhost ~]# chmod a=rwx test
[root@localhost ~]# ll test
-rwxrwxrwx. 1 root root 0 Jan 30 05:19 test

# 取消属组的所有权限
[root@localhost ~]# chmod g= test
[root@localhost ~]# ll test
-rwx---rwx. 1 root root 0 Jan 30 05:19 test

# 取消用户的所有权限
[root@localhost ~]# chmod u= test
[root@localhost ~]# ll test
-------rwx. 1 root root 0 Jan 30 05:19 test

# 给属组增加所有权限
[root@localhost ~]# chmod g=rwx test
[root@localhost ~]# ll test
----rwxrwx. 1 root root 0 Jan 30 05:19 test

# 修改属组的权限只有r
[root@localhost ~]# chmod g=r test
[root@localhost ~]# ll test
----r--rwx. 1 root root 0 Jan 30 05:19 test

# 修改属组的权限在原有基础上增加w
[root@localhost ~]# chmod g+w test
[root@localhost ~]# ll test
----rw-rwx. 1 root root 0 Jan 30 05:19 test

# 修改属组的权限在原有基础上减少w
[root@localhost ~]# chmod g-r test
[root@localhost ~]# ll test
----r--rwx. 1 root root 0 Jan 30 05:19 test

# 修改其他用户的权限在原有基础上减少x
[root@localhost ~]# chmod o-x test
[root@localhost ~]# ll test
----r--r-x. 1 root root 0 Jan 30 05:19 test
[root@localhost ~]#

目录权限操作

　　 使用ll -d来查看某个目录的详细信息，如下所示：

[root@localhost ~]# mkdir testDir
[root@localhost ~]# ll -d testDir
drwxr-xr-x. 2 root root 6 Jan 30 05:51 testDir

　　 对于目录的可读权限来说，意味着能够查看该目录下的内容。

　　 对于目录的可写权限（只限制子代，超子代不限制）来说，意味着能够在此目录中新建、删除、重命名项目，对于项目本身的内容操作并不在此范畴之中，如打开文本文件编辑其内容。

　　 对于目录的执行权限来说，意味着能够cd进该目录中，如果没有x权限，就cd不进去。

　　

　　 权限修改命令chmod

　　 使用chmod也可对目录权限进行操作，操作方式与上述文件权限操作方式相同。不再一一例举。

　　 以下有一些注意事项：

　　 要在某个目录下建立子文件，该目录必须要有w权限，否则不可能建立。

　　 如果对超父目录并没有w权限，那么是不影响在父目录中建立删除子文件的。

属主属组转移

　　 我们既然可以创建一个文件，当然也可将其送给别人。

　　 具体命令就是chown。

　　 属主属组转移命令chown

　　 查看test文件：

[root@localhost ~]# ll test
----r--r-x. 1 root root 0 Jan 30 05:19 test

　　 将其属主变更为yunya，但是属组不变，不加.：

[root@localhost ~]# chown yunya test
[root@localhost ~]# ll test
----r--r-x. 1 yunya root 0 Jan 30 05:19 test

　　 将其属组变更为NewUser用户，加.，注意与上面的区别：

[root@localhost ~]# chown .NewUser test
[root@localhost ~]# ll test
----r--r-x. 1 yunya NewUser 0 Jan 30 05:19 test

　　 chown 名字 是只改属主

　　 chown .名字是只改属组

　　 如果想一次性递归修改目录及其子文件/目录的属主数属组，则命令如下：

chown -R 属主名 .属组名 目录名

　　 如下所示，在testDir文件夹下新建下循环新建了两个子文件，对其进行批量转移属主：

# 循环创建文件
[root@localhost ~]# cd testDir
[root@localhost testDir]# touch {1..3}.txt
[root@localhost testDir]# touch {a..c}.txt
[root@localhost testDir]# cd ..
[root@localhost ~]# ll testDir/*
-rw-r--r--. 1 root root 0 Jan 30 06:17 testDir/1.txt
-rw-r--r--. 1 root root 0 Jan 30 06:17 testDir/2.txt
-rw-r--r--. 1 root root 0 Jan 30 06:17 testDir/3.txt
-rw-r--r--. 1 root root 0 Jan 30 06:17 testDir/a.txt
-rw-r--r--. 1 root root 0 Jan 30 06:17 testDir/b.txt
-rw-r--r--. 1 root root 0 Jan 30 06:17 testDir/c.txt

# 递归转移属主
[root@localhost ~]# chown yunya testDir/*
[root@localhost ~]# ll testDir/*
-rw-r--r--. 1 yunya root 0 Jan 30 06:17 testDir/1.txt
-rw-r--r--. 1 yunya root 0 Jan 30 06:17 testDir/2.txt
-rw-r--r--. 1 yunya root 0 Jan 30 06:17 testDir/3.txt
-rw-r--r--. 1 yunya root 0 Jan 30 06:17 testDir/a.txt
-rw-r--r--. 1 yunya root 0 Jan 30 06:17 testDir/b.txt
-rw-r--r--. 1 yunya root 0 Jan 30 06:17 testDir/c.txt
[root@localhost ~]# 

数字权限

　　 权限所对应的数字：

　　 r -> 4

　　 w -> 2

　　 x -> 1

　　 如果一个文件的权限是754，则该文件权限代表信息如下：

　　 属主：所有权限，4+2+1=1

　　 属组：读和执行权限：4+1=5

　　 其他用户：仅有读权限：4

　　 如下示例，直接使用数字权限对test文件进行权限修改：

[root@localhost ~]# chmod 754 test
[root@localhost ~]# ll test
-rwxr-xr--. 1 yunya NewUser 0 Jan 30 05:19 test

文件操作篇

文档纵向合并

　　 >覆写的使用

　　 >命令可以将一个打印的内容写入到文件中，如果该文件不存在将自动创建，如果文件中已有内容，此操作将覆盖原有内容。

　　 如下所示：

[root@localhost ~]# echo 'Hello,World;' > new_file.txt
[root@localhost ~]# cat new_file.txt
Hello,World;

　　 >>追写的使用

　　 >>命令作用与>命令相同，但是如果原文件中已有内容，该操作不会覆盖原文件内容而是进行追写操作。

　　 如下所示：

[root@localhost ~]# echo 'Hello,Linux' >> new_file.txt
[root@localhost ~]# cat new_file.txt
Hello,World;
Hello,Linux

　　 这两种命令能合并出所有打印的内容，如ls、cat等。

　　 我们也可以一次性指定多个文件进行合并，如下所示：

[root@localhost ~]# cat /etc/passwd /etc/shadow > new_file.txt

　　 这样的话我们合并文件里就有了两个文件的内容了。

文档行数统计

　　 wc命令

　　 使用wc -l [文档路径]对文档的行数进行统计：

[root@localhost ~]# wc -l new_file.txt
88 new_file.txt

　　

文件归档操作

　　 归档和压缩还是有一部分区别的：

　　 归档：相当于去超市买东西，最后拎了一大袋零食出来了

　　 压缩：相当于去超市买完东西，领着一大袋子零食还要把空气挤了

　　 tar命令之打包

　　 我们将对以下文件进行打包操作：

[root@localhost ~]# ls testDir/
1.txt  2.txt  3.txt  a.txt  b.txt  c.txt

　　 使用tar命令进行打包，命令格式如下：

tar -cvf [打包后的名字即存放地址] [被打包文件1] [被打包文件2] [被打包文件N]

　　 如下所示：

[root@localhost ~]# tar -cvf testDir.tar testDir/*
testDir/1.txt
testDir/2.txt
testDir/3.txt
testDir/a.txt
testDir/b.txt
testDir/c.txt

[root@localhost ~]# ll testDir.tar
-rw-r--r--. 1 root root 10240 Jan 30 07:00 testDir.tar

　　 如果想查看一个打包后文件中所包含的内容文件，则使用以下命令：

tar -tf [tar包名]

　　 示例如下：

[root@localhost ~]# tar -tf testDir.tar
testDir/1.txt
testDir/2.txt
testDir/3.txt
testDir/a.txt
testDir/b.txt
testDir/c.txt

　　 tar命令之解包

　　 如果想解包一个tar文件，命令格式如下：

tar -xvf [tar包名] -C [解包的路径（必须存在）]

　　 示例如下：

[root@localhost ~]# mkdir newDir
[root@localhost ~]# tar -xvf testDir.tar -C newDir
testDir/1.txt
testDir/2.txt
testDir/3.txt
testDir/a.txt
testDir/b.txt
testDir/c.txt
[root@localhost ~]# ls newDir/testDir/
1.txt  2.txt  3.txt  a.txt  b.txt  c.txt

　　

文件压缩操作

　　 文件压缩必须依赖压缩算法，让其被压缩后的占空间容量更小，但是原本内容还能提取出来。

　　 压缩的好处有两个，一是节省存储空间，而是在网络传输时能节省用户带宽。

　　 目前在Linux下有两种算法，分别是gzip与bzip2。

　　

　　 gzip压缩与解压

　　 使用gzip进行压缩的命令格式如下：

gzip [被压缩文件]
# 注意：被压缩后的文件都会自动带上后缀.gz

　　 使用gunzip命令对gz类型文件进行解压，命令格式如下：

gunzip [被解压的gz类型文件]

　　 进行示例演示：

[root@localhost ~]# echo 'Hello,Linux' > newFile.txt
# 压缩
[root@localhost ~]# gzip newFile.txt
# 解压
[root@localhost ~]# gunzip newFile.txt.gz

　　 bzip2压缩与解压

　　 使用bzip2进行压缩的命令格式如下：

bzip2 [被压缩文件]
# 注意：被压缩后的文件都会自动带上后缀.bz2

　　 使用bunzip2命令对bz2类型文件进行解压，命令格式如下：

bunzip2 [被解压的bz2类型文件]

　　 进行示例演示：

# 压缩
[root@localhost ~]# bzip2 newFile.txt
# 解压
[root@localhost ~]# bunzip2 newFile.txt.bz2

tar.gz安装包

　　 tar.gz是在Linux下常见的二进制安装包，其实究其原理就是打包和压缩的结合应用。

　　 归档与压缩以及如何压缩目录

　　 上面介绍的命令都不能压缩目录，同时源文件在单纯的压缩后也将被删除，一般来说，我们压缩目录或文件之前都会先对其进行归档，但是如果按照先归档再压缩的命令流程来执行其操作会十分繁琐。

　　 所以这里提供一种非常便捷的压缩目录和文件的方式，并且源文件不会被删除：

tar cvzf [归档并压缩后的包名.tar.gz] [将要归档和压缩的目录/文件名]

　　 解压缩和解包的命令如下：

tar xvf [被归档并压缩后的报名.tar.gz] -C [解包后的存放路径]

　　 示例如下：

# 打包并解压
[root@localhost ~]# tar cvzf testDir.tar.gz ./testDir
./testDir/
./testDir/1.txt
./testDir/2.txt
./testDir/3.txt
./testDir/a.txt
./testDir/b.txt
./testDir/c.txt

# 解压并解包
[root@localhost ~]# tar xvf testDir.tar.gz -C /usr/tmp/
./testDir/
./testDir/1.txt
./testDir/2.txt
./testDir/3.txt
./testDir/a.txt
./testDir/b.txt
./testDir/c.txt

VIM编辑器

　　 vim编辑器作为Linux的自带编辑器可以说十分强大，也被很多追捧的人誉为编辑器之神，它的操作方式非常具有特色但是学习难度较大，所以本章节只会介绍基础操作，感兴趣的小伙伴可以自行学习这一技能，绝对加分不少。

　　 vim编辑器分为两种，一种叫vi，一种叫vim(vi modify)。

　　 vim和vi的基本用法相同，但是某些场景下更为强大。

　　 使用vim编辑器的基本语法：

vim [文件路径]
# 文件不存在将创建

　　 vim有三种模式，如图所示：

　　

　　 以下是命令行模式或扩展模式中一些常用命令或快捷键：

命令/快捷键	描述
h	光标向左移动
l	光标向右移动
j	光标向上移动
k	光标向下移动
dd	删除光标所在的行，一直摁住一直删除
ndd	删除光标所在行下的n行
u	撤销上一步操作
vv	复制光标所在的行
P	粘贴内容到光标所在行的上一行
p	粘贴内容到光标所在行的下一行
gg	跳到文件第一行
G	跳到文件最后一行
nG	跳到文件的第n行
$	跳到当前光标所在行的尾部
0	跳到当前光标所在行的首部
H	光标移动到当前屏幕展示内容区域第一行的第一个字符
M	光标移动到当前屏幕展示内容区域中间行的第一个字符
L	光标移动到当前屏幕展示内容区域最后一行的第一个字符
/	进入搜索模式，支持正则表达式。N是上一个，n是下一个
set nu	显示行号（扩展模式）
CART + R	重做操作

系统与进程篇

Linux启动流程

　　 1.加载BIOS硬件并进行自我测试，获取第一个可启动装置

　　 由BIOS去加载COMS的配置项，配置项包括主机各项硬件信息。然后BIOS会进行自我测试，开始硬件初始化，定义可启动装置的顺序，为下一步读取MBR做准备。

　　 2.读取并运行第一个启动装置内MBR的boot loader程序（该程序也可能是grub，spfdisk等）

　　 BIOS通过INT13读取MBR。

　　 硬盘中第一个扇区MBR中存储启动管理程序Boot Loader，该程序作用是处理并加载核心文件。

　　 3.根据Boot Loader配置加载Kernal，Kernal开始检测硬件并且加载驱动程序

　　 Boot Loader管理读取核心文件之后，Linux系统将会被压缩至主内存中。

　　 此时Linux内核Kernal会再检测一次硬件，但不一定会使用BIOS检测硬件数据。

　　 检测完毕之后，由内核开始接管工作，文件位于/boot/vmlinuz中

　　 4.硬件驱动加载成功后，Kernal主动呼叫init程序，而init程序会获得Run Level资讯

　　 内核会主动呼叫的第一个执行程序就是/sbin/init。

　　 该程序主要功能是准备软件运行环境，包括系统主机名称、网络配置、语系处理、文件系统格式以及其他服务的启动等。

　　 在该程序运行时，会去加载/etc/inittab文件中的项目，该文件主要用于设定Linux运行等级。

　　 默认加载等级为5级及以上：

id:5:initdefault

　　 关于等级划分如下所示：

　　 0：关机，如init 0命令就是调用该等级

　　 1：单用户模式

　　 2：无网络支持的多用户模式

　　 3：有网络支持的多用户模式

　　 4：保留，未使用（开发者模式）

　　 5：有网络支持，有X-Window支持的多用户模式（图形化界面，GUI）

　　 6：重新引导系统，即重启

　　 5.init运行/etc/rc.d/rc.sysinit或init.d文件来准备软件运行的作业环境

　　 在运行等级确定之后，Linux开始执行用户级别的文件，其第一个执行的文件就是/etc/rc.d/rc.sysinit，该脚本程序所做的工作非常多，包括设定PATH，设定网络配置（/etc/sysconfig/network）、启动swap分区，设定/proc等等。

　　 当/etc/rc.d/rc.sysinit脚本执行完成之后，将会从/etc/modules.conf文件或者从/etc/modules.d文件读取配置来装载内核模块。

　　 6.init以Run Level来启动各个服务(script方式)

　　 根据运行级别的不同，系统会在/etc/rc.d目录下运行rc0.d

　　 到rc6.d中对应的脚本程序，来完成初始化工作和启动相应的服务。

　　 7.init运行/etc/rc.d/rc.local文件

　　 该文件加载完毕后，我们就可以对系统发出操作命令，进行用户个性化设置等操作。

　　 8.init运行终端机模拟程序mingetty来启动login程序，等待用户登录后即可使用

　　 运行/sbin/mingetty文件，该文件就是启动终端机的命令，最后将执行/bin/login程序。

　　 扩展阅读

　　 从 CentOS7开始，/etc/inittab下的文件已停用。

　　 https://blog.csdn.net/eaefahdbe/article/details/95739112

　　 CentOs8忘记密码怎么办？查看下面教程：

　　 https://it.baiked.com/linux/4895.html

　　 如何进行MBR加密？保证系统安全？查看下面教程：

　　 https://www.cnblogs.com/junjind/p/8993420.html MBR破解用户密码

　　 https://www.cnblogs.com/kevingrace/p/8387827.html MBR加密

　　 如何对BIOS进行加密？BIOS加密安全吗？

　　 https://baijiahao.baidu.com/s?id=1609967141725113371&wfr=spider&for=pc

任务&内存查看

　　 在Linux中一切皆文件，对于进程而言就是一些正在运行状态中的文件。

　　 文件本身躺在硬盘中是死的，但是当被加载到内存中从而让CPU进行调用的时候就活了过来，因此可以理解为当前正在被CPU调用的文件就是一个进程。

　　 关闭进程知识

　　 什么是关闭进程？

　　 被关闭的进程实际上就是在内存中被释放。这种释放的时机可以是被动的，也可以是手动的，当进程被关闭后将不会占用CPU运算资源以及内存的存储资源了。

　　 Linux进程相关名词

　　 父进程：当程序A运行过程中调用了程序B，程序A可称为程序B的父进程

　　 子进程：当程序A运行过程中调用了程序B，程序B可称为程序A的子进程

　　 守护进程：当程序A运行过程中调用了程序B，而当程序A运行完毕后程序B也被强制关闭，程序B可称为守护进程

　　 僵尸进程：当程序A运行完毕后并未释放所有资源，如进程编号等未被释放，此时的程序A将可以被称为僵尸进程

　　 中断信息：中断信息用于控制进程的运行

　　 动态监控操作系统命令（任务管理器）：top

　　 使用top命令可查看如下信息，节选：

top - 19:18:41 up 17:38,  5 users,  load average: 0.03, 0.04, 0.05
Tasks: 177 total,   1 running, 176 sleeping,   0 stopped,   0 zombie
%Cpu(s):  9.1 us,  2.4 sy,  0.0 ni, 88.5 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :   999936 total,    83316 free,   692712 used,   223908 buff/cache
KiB Swap:  2097148 total,  2042268 free,    54880 used.    92496 avail Mem 

   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
  2861 yunya     20   0 1509200 366360  24612 S  9.0 36.6   2:36.44 gnome-shell
  2308 root      20   0  219124  25416   3876 S  4.3  2.5   0:50.00 Xorg
 46695 yunya     20   0  551872  18888  11260 S  1.3  1.9   0:13.38 gnome-term+
     1 root      20   0  193628   4820   2816 S  0.0  0.5   0:04.68 systemd
     2 root      20   0       0      0      0 S  0.0  0.0   0:00.02 kthreadd
     3 root      20   0       0      0      0 S  0.0  0.0   0:00.46 ksoftirqd/0
     7 root      rt   0       0      0      0 S  0.0  0.0   0:00.00 migration/0

　　 命令窗口描述如下所示：

　　 top - 19:18:41：当前系统时间

　　 up 17:38：本次开机时长

　　 5 users：当前系统登录用户数量

　　 load average: 0.03, 0.04, 0.05：CPU平均负载

　　 Tasks: 177 total, 1 running, 176 sleeping, 0 stopped, 0 zombie：total任务总数，running正在运行，sleeping睡眠进程，stopped暂停的进程，zombie僵尸进程

　　 %Cpu(s)：当前展示多个CPU（百分比显示），可按下数字1显示每个CPU的详细信息

　　 us：用户进程占比

　　 sy：系统进程占比

　　 ni：保存值占比

　　 id：剩余占比

　　 wa：输入输出操作占比

　　 hi：硬件中断占比

　　 gi：软件中断占比

　　 st：CPU被其他虚拟机所占用的百分比

　　 KiB Mem：内存信息

　　 total：总内存

　　 free：剩余内存

　　 used：被使用内存

　　 buff/cache：内存缓冲区

　　 KiB Swap：虚拟内存

　　 total：总内存

　　 free：剩余内存

　　 used：被使用内存

　　 avail Mem：可使用内存

　　 PID：进程号

　　 USER：用户

　　 PR：优先值

　　 NI：排后值

　　 VIRT：虚拟内存占用

　　 RES：物理内存占用

　　 SHR S：贡献内存运行状态，S代表停止，R代表运行

　　 %CPU：进程占用CPU百分比

　　 %MEM： 进程占用内存百分比

　　 TIME+：进程运行时长

　　 COMMAND： 进程描述信息

　　

　　 内存管理器：free

　　 使用free命令详细查看内存使用情况，有以下三种格式：

free 		# 默认显示
free -h 	# 以GB为单位
free -m 	# 以MB为单位

　　 实例演示：

[root@localhost ~]# free -m
              total        used        free      shared  buff/cache   available
Mem:            976         676          80           4         219          89
Swap:          2047          53        1994

　　 解释如下：

　　 total：总内存

　　 used：以使用内存

　　 free：剩余内存

　　 shared：共享内存

　　 buff/cache：高速缓冲区

　　 Mem：物理内存

　　 Swap：虚拟内存

进程管理相关

　　 进程查看命令：ps

　　 使用ps aux命令查看当前操作系统中所有进程及进程详细信息。

　　 使用ps aux | head [-条数]只查看头部几条进程信息。

　　 配合grep或者grep -v进行过滤查找进程。

# 查看头5行
[root@localhost ~]# ps aux | head -5
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.0  0.4 193628  4820 ?        Ss   01:40   0:05 /usr/lib/systemd/systemd --switched-root --system --deserialize 21
root          2  0.0  0.0      0     0 ?        S    01:40   0:00 [kthreadd]
root          3  0.0  0.0      0     0 ?        S    01:40   0:00 [ksoftirqd/0]
root          7  0.0  0.0      0     0 ?        S    01:40   0:00 [migration/0]

# 详细过滤查找
[root@localhost ~]# ps aux | grep 'python' | grep 'yunya'
yunya     52461  0.0  0.4 130012  4988 pts/1    S+   20:20   0:00 python

　　 该命令内容描述如下：

　　 USER：用户名

　　 PID：进程号

　　 %CPU：该进程占CPU的百分比

　　 %MEM：该进程占内存的百分比

　　 VSZ：虚拟内存

　　 RSS：物理内存

　　 TTY：在那个终端（后台）上运行

　　 STAT：当前状态

　　 START TIME：开始时间

　　 COMMAND：产生进程的文件

　　 打开进程

　　 运行一段脚本文件就是打开进程了，如下所示我将打开火狐浏览器。

　　 使用&符将其挂到后台中：

[root@localhost ~]# firefox &
[1] 52680
# 工作号 进程号

　　 结束进程命令:kill

　　 使用kill [进程号(单杀)/进程名(广杀)]来尝试结束进程。

　　 使用kill -9 [进程号(单杀)/进程名(广杀)]来强制结束进程。

　　 下面我将关闭打开的火狐浏览器：

# 先查找
[root@localhost ~]# ps aux | grep 'firefox' | grep 'pts/0'
root      52680  3.6 13.0 983172 130164 pts/0   Sl   20:30   0:05 /usr/lib64/firefox/firefox
root      52861  0.0  0.0 112648   960 pts/0    R+   20:33   0:00 grep --color=auto firefox

# 后关闭
[root@localhost ~]# kill -9 52680
[1]+  Killed                  firefox

　　 子程序前后台操作

　　 当我们在终端以后台方式打开程序后，它将不会影响后续终端的命令输入，并且该程序会有一个工作号和进程号。

　　 在打开任务的终端中，使用jobs可查看在该终端中打开的子程序。

　　 使用fg %[子进程工作号]将该终端下后台运行的子程序调用到前台执行。

　　 使用bg %[子进程工作号]将该终端下前台运行的子程序调用到后台执行。

　　 同时，我们也可使用kill %[子进程工作号]来将该终端下运行的子程序进行释放。

　　 示例如下：

# 后台启动火狐浏览器进程
[root@localhost ~]# firefox &
[1] 53095

# 查看该终端下子进程
[root@localhost ~]# jobs
[1]+  Running                 firefox &

# 跳转前台运行
[root@localhost ~]# fg %1

　　 进程树

　　 使用pstree来查看进程树。

　　 使用pstree | grep ['进程名']来实现广杀。

　　

系统服务

　　 service命令是Redhat Linux兼容的发行版中用来控制系统服务的实用工具，它以启动、停止、重新启动和关闭系统服务，还可以显示所有系统服务的当前状态。

　　 查看运行系统服务运行状态：

service [系统服务名称] status

　　 停止某一系统服务的运行：

service [系统服务名称] stop

　　 重启某一系统服务：

service [系统服务名称] restart

磁盘相关篇

扇区与block块

　　 对于磁盘来说，一次能够读写的大小操作操作系统规定最小要达到一个扇区的大小，即

　　 512Bytes，而操作系统为了避免频繁的同磁盘打交道往往会攒够8个扇区的数据量再进行写入或读取操作，8个扇区因此也被称之为block块。

　　

主分区流程

　　 我们在Vm16中对虚拟机新增一块10GB的磁盘。

　　 此时我们可以立即看到新增的磁盘名为sdb

[root@localhost yunya]# ls /dev/ | grep '^sd'
sda
sda1
sda2
sda3
sdb

　　

　　 开始分区：fdisk

　　 通过fdisk -l /dev/sdb可以查看该硬盘详细信息。

[root@localhost yunya]# fdisk -l /dev/sdb

磁盘 /dev/sdb：10.7 GB, 10737418240 字节，20971520 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：512 字节 / 512 字节

　　 通过命令fdisk /dev/sdb来为该磁盘进行分区。

　　 主分区在MBR中最多存在4个。

　　 扩展分区最多15个，扩展分区无法直接使用，需要在扩展分区下创建逻辑分区。

　　 下面我们直接创建主分区，在命令中有以下一些常用选项：

命令	描述
n	下一步
p	查看详情
d	删除某个分区（按照编号删除）
w	进行应用（fdisk所有操作先存储在内存中，直至你输入了w再进行应用）

　　 以下是分区的示例演示，创建了2个主分区。

[root@localhost yunya]# fdisk -l /dev/sda
欢迎使用 fdisk (util-linux 2.23.2)。

更改将停留在内存中，直到您决定将更改写入磁盘。
使用写入命令前请三思。

# 输入n下一步
命令(输入 m 获取帮助)：n 

# p主分区 e扩展分区
Partition type:
   p   primary (0 primary, 0 extended, 4 free)
   e   extended
Select (default p): p

# 4个主分区
分区号 (1-4，默认 1)：1
起始 扇区 (2048-20971519，默认为 2048)：2048
Last 扇区, +扇区 or +size{K,M,G} (2048-20971519，默认为 20971519)：+5G
分区 1 已设置为 Linux 类型，大小设为 5 GiB

命令(输入 m 获取帮助)：n
Partition type:
   p   primary (1 primary, 0 extended, 3 free)
   e   extended
Select (default p): p
分区号 (2-4，默认 2)：2
起始 扇区 (10487808-20971519，默认为 10487808)：
将使用默认值 10487808
Last 扇区, +扇区 or +size{K,M,G} (10487808-20971519，默认为 20971519)：
将使用默认值 20971519
分区 2 已设置为 Linux 类型，大小设为 5 GiB

命令(输入 m 获取帮助)：w
The partition table has been altered!
Calling ioctl() to re-read partition table.
正在同步磁盘。

　　 现在，我们已经成功在sdb这块硬盘上创建了两个分区。

[root@localhost yunya]# fdisk /dev/sdb
欢迎使用 fdisk (util-linux 2.23.2)。

更改将停留在内存中，直到您决定将更改写入磁盘。
使用写入命令前请三思。

命令(输入 m 获取帮助)：p

磁盘 /dev/sdb：10.7 GB, 10737418240 字节，20971520 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：512 字节 / 512 字节
磁盘标签类型：dos
磁盘标识符：0xda09d20a

   设备 Boot      Start         End      Blocks   Id  System
/dev/sdb1            2048    10487807     5242880   83  Linux
/dev/sdb2        10487808    20971519     5241856   83  Linux

　　 最后一步，进行更新，保存我们的分区内容：

[root@localhost yunya]# partprobe
[root@localhost yunya]# partprobe
[root@localhost yunya]# partprobe
[root@localhost yunya]# partprobe

　　 看一看目录下的文件：

[root@localhost yunya]# ls /dev | grep 'sd'
sda
sda1
sda2
sda3
sdb
sdb1
sdb2

格式化流程

　　 磁盘分区完成后，需要对其进行格式化后才能正常使用。

　　 使用命令mkfs查看当前系统支持的文件系统。在我的Centos7.3中，该命令并未打印出我想要的效果。这里用Centos8的图做个演示：

　　

　　 通常情况下，Linux系统中使用ext4居多，所以我这里就采用ext4进行格式化。

　　 如果能使用xfs，就使用xfs，它单次能支持写入的文件更大。

　　 开始格式化:mkfs

　　 命令如下：

[root@localhost /]# mkfs.ext4 /dev/sdb1
[root@localhost /]# mkfs.ext4 /dev/sdb2

　　 由于我们在上面的示例中创建了2个主分区，所以可以直接使用上述命令进行格式化。如果是拥有扩展分区则无法直接进行格式化，但是逻辑分区则可以。

挂载流程

　　 在分区和格式化完成之后，sdb1-sdb2目前都是属于b类型文件，即硬件设备，并不能直接使用。

　　 因此需要对其进行一个映射操作，这个映射操作则被称为挂载。

　　 说的通俗一点，1个目录对应1个b文件，类似于Windows下的分区于盘符的关系。

　　 开始挂载：mount

　　 第一步，创建两个文件夹，对应sdb1和sdb2：

[root@localhost /]# mkdir /software  # 软件
[root@localhost /]# mkdir /programming  # 程序设计

　　 第二步，使用mount [分区] [目录]对其进行映射：

[root@localhost /]# mount /dev/sdb1 /software
[root@localhost /]# mount /dev/sdb2 /programming

　　 现在，已经挂载完成了，使用命令df查看分区的挂载情况（sr代表光盘）：

[root@localhost /]# df
文件系统          1K-块    已用     可用     已用% 	挂载点
/dev/sda3      18555904 3775092 14780812   21%      /
devtmpfs         485336       0   485336    0% 		/dev
tmpfs            499968     156   499812    1% 		/dev/shm
tmpfs            499968    7268   492700    2% 		/run
tmpfs            499968       0   499968    0% 		/sys/fs/cgroup
/dev/sda1        303780  154604   149176   51% 		/boot
tmpfs             99996       8    99988    1% 		/run/user/1000
tmpfs             99996       0    99996    0% 		/run/user/0
/dev/sdb1       5029504   20472  4730504    1% 		/software
/dev/sdb2       5028480   20472  4729532    1% 		/programming

文件系统

　　 目前我们挂载的文件夹是空的，但是上表中可以看到它有已使用的部分。

　　 在这里面其实存储了文件系统，我们使用mount | tail -2来查看sdb1和sdb2的详细信息，可以看到其使用的文件系统格式是ext4：

[root@localhost /]# mount | tail -2
/dev/sdb1 on /software type ext4 (rw,relatime,seclabel,data=ordered)
/dev/sdb2 on /programming type ext4 (rw,relatime,seclabel,data=ordered)

　　 对于一个文件来说，即使该文件是内容是空白的，它依然会占据一些空间。

　　 一个新建的文件，除开其本身存储的内容之外还具有文件名 - 权限 - 硬链接数量 - 属主 - 属组 - 大小 - 创建时间 等信息，我们统一把这些信息称为元数据。这些内容都是要占用空间的，那么元数据是存放在哪里的呢？

　　 前面讲过bolck块的概念，一个分区的bolck块叫做数据bolck块，专门存放文件的数据，还有一个inoode块，就是专门来存放文件元数据的，存储在innode中的元数据也被称为i节点信息。

　　 硬盘只要格式化成文件系统之后都会被分成两部分，如下图所示：

　　

　　

　　 使用命令，df -i可查看每个分区的i节点信息：

[root@localhost /]# df -i | tail -2
文件系统         Inode 	已用(I) 	可用(I) 		已用(I)% 		挂载点
/dev/sdb1       327680  11  	327669         1% 			/software
/dev/sdb2       327680  11  	327669         1% 			/programming

　　 其实，在硬盘中存放一个文件的时候，都会给这个文件提供i节点进行存储元信息，如果是一个空文件，它虽然内容不占block大小但是还是占用innode大小。所以如果innode块被占满了那么磁盘也就被沾满了。

　　 把磁盘比喻成一个考室，一个位置相当于一个innode编号，如果这个考室座位上没有一个人，但是都有其专属考生的编号，那么这个考室就无法安排其他考生入内了。

　　 这种情况映射到硬盘上就是说硬盘空间还有很多，但是innode号不够用了，磁盘也就满了。

　　 使用ll -i [名字]来查看一个文件和目录的编号：

# 查看文件的innode编号
[root@localhost /]# ll -i /etc/passwd
18670796 -rw-r--r--. 1 root root 2296 1月  30 04:56 /etc/passwd

# 查看目录的innode编号
[root@localhost /]# ll -i / | grep 'etc'
16777281 drwxr-xr-x. 138 root root 8192 2月   1 02:24 etc

　　 每个innode块有两部分。分为innode编号和元信息，他们都指向同一个件。是用的指针来指的所以速度很快。

　　

　　 directory block就是目录块，目录的地址。当一个文件被存储进block块，会执行以下流程：

　　

软硬链接

　　 软链接

　　 软链接在Linux下非常常用，类似于Windows下的快捷方式。

　　 命令格式如下：

ln -s [被链接的源文件] [链接投放地点]

　　 软链接特点如下：

　　 1.软链接或者源文件内容有任何改变，都会影响到对方

　　 2.删除源文件，软链接将会失效，删除软链接，源文件不变

　　 3.软链接与源文件的innode号不一样

　　 4.软链接指向源文件名词

　　 5.软链接可以跨分区

　　 硬链接

ln [被链接的源文件] [链接投放地点]

　　 硬链接特点如下：

　　 1.硬链接或者源文件内容有任何改变，都不会影响到对方

　　 2.删除源文件，硬链接不会失效，删除硬链接，源文件不会改变

　　 3.硬链接是指向源文件的innode号的

　　 4.硬链接无法跨分区

网络管理

基本介绍

　　 根据TCP/IP协议。连接在Internet上的计算机每一个都要有一个IP地址，IP地址由八位二进制数构成，用十进制验算则是四个0-255之间的数字。

　　 IP地址分为网络地址和主机地址两部分，网络地址就是用来标识采用此IP的计算机处于哪个子网，主机地址用来标识处于具体的那一个位置，单纯的IP地址是看不出子网的，必须要通过掩码。如后面加上/16，那么就表明这段IP的前16位代表网络位，后16位代表主机位，如果要写一个IP地址的网络地址那么只需要将前面网络位的数字写出来就好，主机位全部置0，而主机地址就是本身。比如：

　　

　　 将IP地址中的网络位和主机位固定下来，IP地址被分成了不同的类集，被分成了A，B，C，D，E类:

　　 常见的三类：

　　 A类地址：前8位都是网络位，后面24位是主机位。1 - 126（掐头去尾）

　　 B类地址：前16位都是网络位，后16位是主机位。128 - 191（掐头去尾）

　　 C类地址：前24位都是网络位，后8位是主机位。192 - 223（掐头去尾）

　　 不常见的两类：

　　 D类地址：通常用于广播，多播。224 - 239

　　 E类地址：保留地址，240 - 255

　　 IP地址可以用子网掩码来实现多层隔离，通过借位的方式可以让一类地址细化分成更多的广播域，用来阻止网络风暴的发生。

　　 使用IP地址来算子网地址。比如：192.167.45.1/24

# 异或运算
b ‘11000000.10100111.00101101.00000001
b ’11111111.11111111.11111111.00000000
b ‘11000000.10100111.00101101.00000000

　　 这个就是子网划分出的地址。192.167.45.0 ，只有网络地址一样，才能进行内部广播通信。

虚拟机网络

　　 在Vm中，虚拟机拥有以下三种网络：

　　

　　 Bridged（桥接模式）：通过虚拟网桥进行通信和联网，不需要虚拟网卡来使虚拟机和物理机通信。使用桥接模式，虚拟机IP地址需和物理层面上的客户机处于同一网段。通过物理交换机链接Internet

　　 NAT（网络地址转换）模式：NAT模式的虚拟机和物理机的IP地址不能处于同一网段。因为要将虚拟机的IP地址转换为物理机的网关所在IP地址然后再进行发包链接。NAT在计算机网络中是很常见的一种模式.

　　 Host-Only（仅主机模式）：实验用的，如果使用仅主机模式。那么虚拟机A与虚拟机B使用同一网段，将会实现通信发包。

链接网络

　　 我们准备使用桥接模式来让虚拟机获取网络服务，因此需要先查看物理机的IP地址，物理机是Windows所以打开CMD命令输入ipconfig获取物理机IP地址：

无线局域网适配器 WLAN:

   连接特定的 DNS 后缀 . . . . . . . :
   IPv6 地址 . . . . . . . . . . . . : 2409:8962:3405:2ae4:ed01:6743:4b9e:7b14
   临时 IPv6 地址. . . . . . . . . . : 2409:8962:3405:2ae4:d810:fde0:ca6c:8c6e
   本地链接 IPv6 地址. . . . . . . . : fe80::ed01:6743:4b9e:7b14%8
   IPv4 地址 . . . . . . . . . . . . : 192.168.43.101
   子网掩码  . . . . . . . . . . . . : 255.255.255.0
   默认网关. . . . . . . . . . . . . : fe80::6c61:6bff:fee6:c51e%8
                                       192.168.43.1

　　 可以看到网段是30，接下来我们需要为虚拟机增加网络设备并将其配置为桥接模式。

　　

　　

　　 使用ifconfig获得网卡信息：

ens36: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.43.107  netmask 255.255.255.0  broadcast 192.168.43.255
        inet6 2409:8962:3405:2ae4:551b:c0bf:5b87:57a7  prefixlen 64  scopeid 0x0<global>
        inet6 fe80::6a5b:c124:1637:48f8  prefixlen 64  scopeid 0x20<link>
        ether 00:0c:29:d1:92:d3  txqueuelen 1000  (Ethernet)
        RX packets 104  bytes 14003 (13.6 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 136  bytes 14249 (13.9 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1  (Local Loopback)
        RX packets 4  bytes 340 (340.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4  bytes 340 (340.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

virbr0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        inet 192.168.122.1  netmask 255.255.255.0  broadcast 192.168.122.255
        ether 52:54:00:d8:0d:c4  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

　　 发现网卡ens36，自动配置的ip地址等都正确，尝试ping百度。成功：

[root@localhost network-scripts]# ping www.baidu.com
PING www.a.shifen.com (39.156.66.14) 56(84) bytes of data.
64 bytes from 39.156.66.14 (39.156.66.14): icmp_seq=1 ttl=51 time=107 ms
64 bytes from 39.156.66.14 (39.156.66.14): icmp_seq=2 ttl=51 time=70.8 ms
64 bytes from 39.156.66.14 (39.156.66.14): icmp_seq=3 ttl=51 time=64.0 ms

网络配置项

　　 罗列一些centos中常用的网络配置项命令即配置文件。

　　 在Linux中，所有永久的操作都必须通过文件修改。

　　 通过命令修改只能是本次关机前生效，下次开机后失效。

　　 首先是网卡配置，它的配置文件放在：/etc/sysconfig/network-scripts/ifcfg-网卡名。如果你已经能联网了，就不许要配置该文件了。

　　 网卡配置文件：

TYPE=Ethernet  		# 类型
BOOTPROTO=static 	# static  dhcp
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=no
NAME=ens36			# 网卡名称
UUID=bf5337ab-c044-4af7-9143-12da0d493b89
DEVICE=ens36		# 和名称相同
PEERDNS=yes
PEERROUTES=yes
IPV6_PEERDNS=yes
IPV6_PEERROUTES=yes
ONBOOT=yes 			 # 修改成 yes
IPADDR=192.168.43.238 # Linux的IP地址，与物理机相同网段
NETMASK=255.255.255.0   #  子网掩码，与物理机相同
GATEWAY=192.168.43.1    #  默认网关，与物理机相同
DNS1=114.114.114

　　 想让配置文件成功，就需要重启网络服务：

[root@localhost network-scripts] service network restart

# centos8采用新命令
nmcil c reload

　　 关于网络服务的守护进行永久开启与关闭：

[root@localhost network-scripts] chkconfig NetworkManager off  # 关闭
[root@localhost network-scripts] chkconfig NetworkManager on   # 打开

　　 关闭和开启网卡：

ifup [网卡名]    # 立即启用网卡
ifdown [网卡名]  # 立即关闭网卡

　　 查看网络配置：

[root@localhost network-scripts]# route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         192.168.43.1    0.0.0.0         UG    100    0        0 ens36
192.168.43.0    0.0.0.0         255.255.255.0   U     100    0        0 ens36
192.168.122.0   0.0.0.0         255.255.255.0   U     0      0        0 virbr0

# 第一行为网络出口配置
# 第二行和第三行为网络入口配置

　　 查看修改主机名：

hostname [新名字]  # 如果不填名字则是查看主机名

　　 临时添加网关：

route add gw [ip地址]
route add gw default [ip地址]  # 添加默认网关

　　 永久修改DNS服务器：

vim /etc/resolv.conf

　　 本地HOSTS文件：

vim /etc/hosts

　　 防火墙相关：

iptables -F # 清空防火墙规则
service iptables stop # 关闭防火墙

软件服务

tar.gz与rpm

　　 在Linux操作系统中。有两种安装包，一种是tag.gz为后缀名的安装包，还有一种是后缀名为rpm的安装包。

　　 tag.gz我们在前面已经学习过，其实内部就是一些软件的源代码归档压缩而成，解压后执行./即可安装。这种被称为编译安装。

　　 为什么叫编译安装呢？ 因为在计算机的内部执行的都是1和0这两个数字，所以所有的执行命令，其实都是在内存中经过字符编码转换为二进制数，在转换过程中进行安装即被称为编译安装。

　　 rpm安装包最早由红帽公司推出。与tag.gz安装包最大的不同在于其本身已经是被编译好了的二进制，所以安装起来会省去字符编码转换的过程，CentOS官方已经帮忙编译了很多tag.gz的安装包为rpm格式。但是操作系统的开发商不会时时刻刻对这些软件进行升级和更新，如果想使用最新的最全面的软件体验。那么请使用tag.gz后缀的安装包。

tar.gz安装

　　 上面其实已经说过了，它的内部原理是将多个项目先进行归档后再进行压缩。

　　 一般来说我们只需要对其进行解包和解压即可：

tar xvf [被归档并压缩后的报名.tar.gz] -C [解包后的存放路径]

rpm基础介绍

　　 使用rpm时，会先从本地找以提供的安装包。

　　 如果本地未找到，则会联网进行查找。

　　 连接并自动挂载含有将本地rpm安装包的光盘：

　　

　　 使用df命令查看该光盘的映射路径：

[root@localhost yunya]# df | grep 'sr'
/dev/sr0             4276440 4276440        0  100% /run/media/yunya/CentOS 7 x86_64

# sr代表光盘

　　 查看该目录下Packages子目录下的项目：

[root@localhost Packages]# ls /run/media/yunya/CentOS\ 7\ x86_64/Packages/ | head -5

389-ds-base-1.3.5.10-11.el7.x86_64.rpm
389-ds-base-libs-1.3.5.10-11.el7.x86_64.rpm
abattis-cantarell-fonts-0.0.16-3.el7.noarch.rpm
abrt-2.1.11-45.el7.centos.x86_64.rpm
abrt-addon-ccpp-2.1.11-45.el7.centos.x86_64.rpm

　　 现在，我们就可以看到Centos7.3中内置的一些rpm安装包，它的解读格式如下：

　　 以 . 来分段，倒着看更清晰：

　　 第1段是软件包的名称

　　 第2段是软件版本编号

　　 第3段软件包的修正次数

　　 第4段代表支持的平台

　　 第5段代表CPU架构

　　 最后一部分就是文件扩展名

　　 软件包版本号如果最后一位是奇数的话，那么就表明这个软件还处于测试阶段，可能有一些BUG等不确定因素，不具有稳定性，反之偶数就是稳定版。

rpm基本命令

　　 安装：

rpm -ivh [rpm包名] 			# 可选项 -h哈希值 -v详细信息
rpm -ivh [rpm包名] --force 	# 强制安装（即使已存在）

　　 查看：

rpm -aq 		  # 查看所有已安装，可配合`rep`滤
rpm -q [软件名]	# 查看某个软件是否以安装
rpm -ql[软件名]    # 查看某个软件的安装位置
rpm -qi[软件名]	# 查看某个软件的安装详情

　　 卸载：

rpm -e [软件名] # 可能出问题
rpm -e [软件名]  --nodeps # 强制卸载

　　 示例演示：

[root@localhost Packages]# rpm -ivh dnsmasq-2.66-21.el7.x86_64.rpm --force
警告：dnsmasq-2.66-21.el7.x86_64.rpm: 头V3 RSA/SHA256 Signature, 密钥 ID f4a80eb5: NOKEY
准备中...                          ################################# [100%]
正在升级/安装...
   1:dnsmasq-2.66-21.el7              ################################# [100%]

[root@localhost Packages]# rpm -aq | grep 'dnsmasq'
dnsmasq-2.66-21.el7.x86_64

[root@localhost Packages]# rpm -e dnsmasq --nodeps

[root@localhost Packages]# rpm -aq | grep 'dnsmasq'
[root@localhost Packages]#

rpm在线自动安装

　　 在线自动安装

　　 通过CentOS官网进行下载rpm安装包。再手动安装

　　 首先查看自身系统编号：

[root@localhost Packages]# cat /etc/redhat-release
CentOS Linux release 7.3.1611 (Core)

　　 进入官网mirror.centos.org

　　

　　 复制出连接直接安装就好：

rpm -ivh [链接]

wget手动下载安装

　　 注意pwd位置一定要在你想要下载到的位置。

　　 使用wget跟上链接地址，这种方式非常常用！

wget [链接]

yum基本命令

　　 使用上面的rpm安装方式会经常遇见一个问题。那就是依赖组件的问题，很多依赖组件莫名其妙不知道是什么东西去哪里下载，那么如何解决这个问题呢？可以使用yum来解决。

　　 yum会自动安装rpm软件，并且会自动安装其依赖软件。

　　 基本命令：

yum install [软件名]  	  # 安装某个软件, 使用 -y 来让所有选项都确定，yum install [软件名] -y
yum remove [软件名]   	  # 卸载某个软件
yum reinstall [软件名]	  # 更新某个软件
yum makecache 		 	# 创建缓存文件，有效提升网络安装的速度
yum clean all		 	# 清理缓存
yum groupulist			# 批量安装成批工具，如yum groupulist '开发者工具'

yum与依赖环境

　　 yum分为本地仓库和远程仓库。

　　 建立本地仓库

　　 手动配置yum仓库文件：

# 新建仓库文件
[root@localhost /]# vim /etc/yum.repos.d/local.repo

# file路径必须//开头跟上路径
[local]
name=local yum
baseurl=file:///run/media/yunya/CentOS\ 7\ x86_64/
enabled=1
gpgcheck=0

# 意思就是所使用yum命令时，从该路径安装rpm包

　　 查看仓库

　　 除开我们自己配置的仓库外，其实他还有很多的自带仓库。可以查看/etc/yum.repos.d，这些文件都是网络源。

[root@localhost /]# ls /etc/yum.repos.d/
CentOS-Base.repo  CentOS-Debuginfo.repo  CentOS-Media.repo    CentOS-Vault.repo
CentOS-CR.repo    CentOS-fasttrack.repo  CentOS-Sources.repo  local.repo

　　

　　 yum执行流程

　　 那么yum安装的流程到底是怎么样去执行的呢？怎么样找到依赖关系并找到安装包？可以看下面的这张图。

　　

　　

　　 如果仓库里给定的路径没有repodata这个目录，那么必定安装失败。

　　 以上这些都是yum的一个原理流程图。我们可以查看一下在本地镜像中的repodata/repomd.xls

[root@localhost /]# ls /run/media/yunya/CentOS\ 7\ x86_64/repodata/ | grep 'repomd.xml'
repomd.xml

　　 这个就是依赖环境的文件，通过这个文件可以找到Packages下的所有安装包进行安装，如果没有就不会安装，而是通过网络的方式去查看repodata文件。

　　 在这里也可以看到基于网络的仓库信息。它的路径是在/etc/yum.repos.d下面。

　　 我们打开了BASE这个网络仓库，节选代码：

#released updates
[updates]
name=CentOS-$releasever - Updates
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=updates&infra=$infra
#baseurl=http://mirror.centos.org/centos/$releasever/updates/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7

　　 我们随便复制一个baseurl并对其进行访问，来看一下有没有repodata和PackAges目录：

baseurl=http://mirror.centos.org/centos/$releasever/updates/$basearch/
进行模板转换：
baseurl=http://mirror.centos.org/centos/7/updates/x86_64/

# $contentdir --> 系统版本，如centos-7
# $releasever --> 详细版本，如7
# $basearch   --> 平台架构，如x86_64

　　 可以看到是有的。

　　

　　 配置yum下载目录

　　 通过网路查找依赖关系：repodata/repomd.xml后就可以进入Packages进行安装。那么网络上rpm安装包肯定是要下载到本地后在进行安装的。可以通过/etc/yum.conf来配置它默认下载的路径和完成安装后是否清理安装包的选项。

vim /etc/yum.conf

　　 打开文件的第一行，可以设置安装包下载路径，第二行如果设置成1就代表完成安装后不清理安装包而是保存。

SSH服务

基本介绍

　　 我们知道，对于服务器来说一般都是存在远端。当服务器发生异常之后我们需要使用一款软件对其服务器进行远程操控排除异常，那么在Linux中都自带了这样的一款软件，名为ssh。

　　 这是一款C/S架构软件，Linux系统拥有它的Client端和Server端，使用如下命令可查看到ssh服务依赖的安装程序：

[yunya@localhost network-scripts]$ rpm -qa | grep 'openssh'
openssh-server-6.6.1p1-31.el7.x86_64
openssh-clients-6.6.1p1-31.el7.x86_64
openssh-6.6.1p1-31.el7.x86_64

　　 查看sshd（服务端）运行状态：

[yunya@localhost network-scripts]$ service sshd status
Redirecting to /bin/systemctl status  sshd.service
● sshd.service - OpenSSH server daemon
   Loaded: loaded (/usr/lib/systemd/system/sshd.service; enabled; vendor preset: enabled)
   Active: active (running) since 二 2021-02-09 20:44:32 CST; 42min ago
     Docs: man:sshd(8)
           man:sshd_config(5)
  Process: 1050 ExecStart=/usr/sbin/sshd $OPTIONS (code=exited, status=0/SUCCESS)
 Main PID: 1078 (sshd)
   CGroup: /system.slice/sshd.service
           └─1078 /usr/sbin/sshd
[yunya@localhost network-scripts]$

　　 使用ssh（客户端命令）链接远程服务器，推荐软件：Xshell/putty/secureCRT/VNC等，这里我采用git的命令行工具，它也提供了ssh客户端。

　　 以下示例中，我是物理机链接虚拟机Centos7.3：

$ ssh 192.168.0.101

The authenticity of host '192.168.0.101 (192.168.0.101)' can't be established.
ECDSA key fingerprint is SHA256:LqrxiB4AbXC1dXX6Lew7kAjbihBXRh8MTu1y7Dl36+A.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '192.168.0.101' (ECDSA) to the list of known hosts.
yunya@192.168.0.101's password:
Last login: Tue Feb  9 20:45:03 2021
[yunya@localhost ~]$ su root
密码：
[root@localhost yunya]# cd /
[root@localhost /]# ls
1    boot  etc   lib    media  opt   root  sbin  sys  usr
bin  dev   home  lib64  mnt    proc  run   srv   tmp  var
[root@localhost /]#

工作机制

　　 服务器启动的时候自己产生一个密钥(768bit公钥)，本地的ssh客户端发送连接请求到ssh服务器，服务器检查连接点客户端发送的数据和IP地址，确认合法后发送密钥(768bits)给客户端，此时客户端将本地私钥(256bit)和服务器的公钥(768bit)结合成密钥对key(1024bit),发回给服务器端，建立连接通过key-pair数据传输。

　　

　　 客户端主动联机请求：

　　 若客户端想要联机到 ssh 服务器，则需要使用适当的客户端程序来联机，包括 ssh, putty 等客户端程序连接。

　　 服务器传送公钥给客户端：

　　 接收到客户端的要求后，服务器便将第一个步骤取得的公钥传送给客户端使用 (此时应是明码传送，反正公钥本来就是给大家使用的)。

　　 客户端记录并比对服务器的公钥数据及随机计算自己的公私钥：

　　 若客户端第一次连接到此服务器，则会将服务器的公钥记录到客户端的用户家目录内的 ~/.ssh/known_hosts 。若是已经记录过该服务器的公钥，则客户端会去比对此次接收到的与之前的记录是否有差异。若接受此公钥， 则开始计算客户端自己的公私钥。

　　 回传客户端的公钥到服务器端：

　　 用户将自己的公钥传送给服务器。此时服务器：具有服务器的私钥与客户端的公钥，而客户端则是： 具有服务器的公钥以及客户端自己的私钥，你会看到，在此次联机的服务器与客户端的密钥系统 (公钥+私钥) 并不一样，所以才称为非对称加密系统。

　　 开始双向加解密：

　　 (1)服务器到客户端：服务器传送数据时，拿用户的公钥加密后送出。客户端接收后，用自己的私钥解密

　　 (2)客户端到服务器：客户端传送数据时，拿服务器的公钥加密后送出。服务器接收后，用服务器的私钥解密，这样就能保证通信安全。

客户端连接

　　 最简单的ssh命令只需要指定用户名和主机名参数即可. 主机名可以是 IP 地址或者域名. 命令格式如下:

$ ssh [用户名]@[地址]

　　 默认连接到目标主机的 22 端口上,但是由于各种原因你可能需要连接到其他端口.

$ ssh -p [端口号] [用户名]@[地址]

服务端配置

　　 使用vim对/etc/ssh/sshd_config文件进行配置，如你可以关闭UserDns选项使ssh链接更加迅速：

#UseDNS yes
UseDns no

scp文件传输

　　 使用scp命令可以将本地文件上传到Linux服务端，命令如下：

scp -r [本地文件路径] [用户名]@[地址]:[上传的路径]

　　 示例如下：

# 本地上传
yunya@DESKTOP-KRBGCGL MINGW64 ~/Desktop
$ scp -r ./Snipaste_2020-11-24_18-30-40.png root@192.168.0.101:/home/yunya
root@192.168.0.101's password:
Snipaste_2020-11-24_18-30-40.png              100% 1076KB  13.2MB/s   00:00

# ssh链接
yunya@DESKTOP-KRBGCGL MINGW64 ~/Desktop
$ ssh root@192.168.0.101
root@192.168.0.101's password:
Last login: Tue Feb  9 21:51:30 2021 from 192.168.0.102

# 查看已上传的文件
[root@localhost ~]# ls /home/yunya
Snipaste_2020-11-24_18-30-40.png  模板  图片  下载  桌面
公共                              视频  文档  音乐
[root@localhost ~]#

基本软件安装

环境变量

　　 软链接（推荐）

　　 当你的软件安装完成之后，每次都需要去安装目录里启动它非常麻烦，我们可以在bin目录下做一条软连接：

ln -s [软件启动程序路径] /bin/[软链接名称]

　　

　　

　　

　　 /etc/profile文件修改

　　 不常用，软链接比较方便。

vim /etc/profile
# 按下大写G，跳到最后一行
写上PATH=软件启动程序路径
换行写上export PATH

　　

开发者工具

　　 安装开发者工具包与可能的依赖：

>: yum -y groupinstall "Development tools"
>: yum install openssl-devel bzip2-devel expat-devel gdbm-devel readline-devel sqlite-devel psmisc libffi-devel

　　 　　 检测git是否安装成功：

>: git

redis安装

1）前往用户根目录
>: cd ~

2）下载redis-5.0.5
>: wget http://download.redis.io/releases/redis-5.0.5.tar.gz
# 如果本地有就上传
>: scp -r C:\Users\dell\Desktop\pkg\redis-5.0.5.tar.gz root@39.99.192.127:~

3）解压安装包
>: tar -xf redis-5.0.5.tar.gz

4）进入目标文件
>: cd redis-5.0.5

5）编译环境
>: make

6）复制环境到指定路径完成安装
>: cp -r ~/redis-5.0.5 /usr/local/redis

9）建立软连接
>: ln -s /usr/local/redis/src/redis-server /usr/bin/redis-server
>: ln -s /usr/local/redis/src/redis-cli /usr/bin/redis-cli

10）后台运行redis
>: cd /usr/local/redis
>: redis-server &

ctrl + c 停止

11）测试redis环境
>: redis-cli
ctrl + c

12）关闭redis服务
>: pkill -f redis -9

mysql安装

1）前往用户根目录
>: cd ~

2）下载mysql57
>: wget http://dev.mysql.com/get/mysql57-community-release-el7-10.noarch.rpm

也可以本地上传，这条命令要在本地终端上执行
>: scp -r C:mysql57-community-release-el7-10.noarch.rpm root@39.99.192.127:~

3）安装mysql57
>: yum -y install mysql57-community-release-el7-10.noarch.rpm
>: yum -y install mysql-community-server

4）启动mysql57并查看启动状态
>: systemctl start mysqld.service
>: systemctl status mysqld.service

5）查看默认密码并登录
>: grep "password" /var/log/mysqld.log
>: mysql -uroot -p

6）修改密码，密码不能太简单 我的密码：'Csh980128%%%'
>: ALTER USER 'root'@'localhost' IDENTIFIED BY 'new password';

python安装

1）前往用户根目录
>: cd ~

2）下载 或 上传 Python3.6.7
# 服务器终端
>: wget https://www.python.org/ftp/python/3.6.7/Python-3.6.7.tar.xz

# 本地终端，给服务器上传
>: scp -r 本地Python-3.6.7.tar.xz ssh root@39.99.192.127:服务器路径
>: scp -r C:\Users\dell\Desktop\pkg\Python-3.6.7.tar.xz ssh root@39.99.192.127~

3）解压安装包
>: tar -xf Python-3.6.7.tar.xz

4）进入目标文件
>: cd Python-3.6.7

5）配置安装路径：/usr/local/python3
>: ./configure --prefix=/usr/local/python3

6）编译并安装
>: make && sudo make install

7）建立软连接：终端命令 python3，pip3
>: ln -s /usr/local/python3/bin/python3.6 /usr/bin/python3
>: ln -s /usr/local/python3/bin/pip3.6 /usr/bin/pip3

8）删除安装包与文件：
>: rm -rf Python-3.6.7
>: rm -rf Python-3.6.7.tar.xz

nginx安装

1）前往用户根目录
>: cd ~

2）下载nginx1.13.7
>: wget http://nginx.org/download/nginx-1.13.7.tar.gz

3）解压安装包
>: tar -xf nginx-1.13.7.tar.gz

4）进入目标文件
>: cd nginx-1.13.7

5）配置安装路径：/usr/local/nginx
>: ./configure --prefix=/usr/local/nginx

6）编译并安装
>: make && sudo make install

7）建立软连接：终端命令 nginx
>: ln -s /usr/local/nginx/sbin/nginx /usr/bin/nginx

8）删除安装包与文件：
>: cd ~
>: rm -rf nginx-1.13.7
>: rm -rf nginx-1.13.7.tar.xz

9）测试Nginx环境，服务器运行nginx，本地访问服务器ip
>: nginx
>: 服务器绑定的域名 或 ip:80

#Nginx命令
1）启动
>: nginx

2）关闭nginx
>: nginx -s stop

3）重启nginx
>: nginx -s reload

4）查看端口，强行关闭
>: ps -aux|grep nginx
>: kill <pid:进程编号>