【linux学习笔记】一、基础

自己写应用 自己写接口  自己部署模型
https://www.zhihu.com/question/25627482
https://blog.csdn.net/sinat_30353259/article/details/81052399

操作系统：Linux教程--------------------那个爱打luwalu的

目前我们用的操作系统以windows为主，此外还有的同学是mac本就是苹果系统。
以后会接触到性能、性能优化、硬盘和内存之间的关系，应该怎么处理硬盘和内存之间的关系等问题，都是在了解操作系统的基础上你才能深刻理解的。所以学习操作系统是必须的。
Linux操作系统是一个基于POSIX和Unix的多用户、多任务、支持多线程和多cpu的操作系统。
linux操作系统中会出现很多windows的影子，那为什么不直接讲windows呢，因为在程序员的世界中，90%以上的服务器都是linux系统的架构来构成的。所以以后要学习服务器必须要先学习一下linux系统的操作。
目前有的同学装的linux是一个有界面版本的操作系统，但这种有界面版本的并不是企业中使用的linux，企业中用于作服务器的linux绝大部分都是以无窗口的，无视窗界面的，就是一个小黑窗口，就是cmd进入的窗口。在这个小黑窗口里面操作的，这才是一个标准的Linux。因为对于服务器来讲要桌面都是多余的浪费资源浪费内存，因为要呈现一个桌面是要占用内存的。所以我们要学的都是无界面的。只有极少数公司用的是有界面的linux。比如外企用的开发环境就有可能是ubantu+idear就是有界面的。
#计算机硬件软件体系
#计算机硬件之冯诺依曼体系，冯诺依曼体系结构：
1、计算机处理的数据和指令一律用二进制数表示，并且数据和指令都是存储在内存中。
2、顺序执行程序
3、计算机硬件由运算器，控制器，存储器，输入输出设备五大部分组成。计算机硬件的构成就是遵循这个体系。
输入设备是用来将人类熟悉的信息形式转换为机器能够识别的信息形式。比如键盘、鼠标等。
输出设备可以将机器运算结果转换为人们熟悉的信息形式，比如打印机输出，显示器输出等。
存储器是用来存储数据和程序的。有ram和 rom两种模式，内存就是ram，硬盘就是rom模式。ram速度快、容量小，掉电易失，属于逻辑IO。rom容量大速度慢永久保存，属于物理IO。所以内存就是cpu和硬盘之间的桥梁或者中转站的作用。比如我们在某一段时间点我们经常运行那些应用程序，我们就可以把这些应用程序提前放到硬盘中，这样就可以快速加载。所以以后我们的很多操作能在内存中执行的就尽量放在内存中运行。
cpu包括运算器ALU和控制器。控制器用来控制和指挥程序和数据的输入运行，以及处理计算结果的。运算器主要是进行算术运算和逻辑运算，并将中间结果暂存到运算器中。
也就是输入设备输入指令和数据，指令和数据进入存储器(内存)，内存再把指令和数据送到cpu的指令寄存器，cpu指令寄存器接受到指令和数据后先解码这个是数据还是指令，是数据就传递给运算器，是指令就传递给控制器，数据经过运算器运算完毕再传回存储寄存器，指令解析完毕就开始执行。存储寄存器再将结果传给内存。
数据的大小和占用空间的大小是不一样的，因为数据大小就是数据的大小，但是要存储这个数据就是要给这块数据一个存储空间，而存储空间是按扇区划分的，所以存储空间一定比数据大小大一些。一个扇区是4kb，也就是传说中的4k对其。
#顺序读写和随机读写
一般数据存储在硬盘中都不是顺序读写的，就是一个文档的数据不是写在硬盘的连续的一个空间里。所以是随机读写的。随机读写虽然写得快了，但读时就效率不高了。要解决这个问题，我们在硬盘储存文档的时候，一个文档不管它实际有多大，我们都将硬盘的划分为一块块足够大的空间来存储一个文件。这样文件虽然在它所在的那块磁盘空间中是随机写入的，但读的时候它虽是随机的但它们都在的是这一块区间，这样就提高了读取的速度。这样的代价就是每个文件存储的磁盘块都要大于文件的大小，这样磁盘的利用率就不高。
还有就是磁盘扇区的划分，等区划分完硬盘后，每个扇区排列的序号不是顺序排列的，而是间隔排列的，就是第0个扇区确定以后，第1个扇区不是紧挨着第0个扇区而和第0个扇区间隔一个扇区。这样的排列也是为了读取时性能提升一点。
#网络连接
网络连接是为了计算机和计算机之间的通信。网络连接最基本的有4个参数，从ipv4协议看，有ip地址，子网掩码，默认网关，DNS,这四个是必填的。如果我们不需要外网，默认网关可以不填，有时dns也可以不填，因为现在都是自动解析。
不管是windows系统还是Linux系统都遵守这套协议。
ip地址IPADDR，ip地址是一种逻辑地址，用来标识网络中的主机。IP地址=网络地址+主机地址
ip地址应该是唯一的，如果两台机器的ip地址相同了就相当于两部手机的电话号码相同了，就相当于发出去的包就不知道要发给谁了，这就是ip地址的作用。一个ip地址由4个字节来构成，一个字节是8位，所以ip的一个字节就是0-255。但是0、1、255一般不要用。
子网掩码netmask,就是将ip地址划分为网络地址和主机地址两部分。子网掩码用来判断任意两台计算机的ip地址是否在同一个子网中的根据。就类似于电话号码中的区号和电话号码，子网掩码就是来区分那些是区号哪些是电话号码，区号相同标识电话在一个地区，不同区号表示在不同的区域。一般子网掩码都是255.255.255.0，这个掩码会和ip地址做与运算。与运算就是两个都是1才会是1。掩码中都是255意思就是都是1，所以只有ip地址中1的位就运算结果也是1，如果Ip地址中的0就运算结果是0，就是还是ip地址，所以如果掩码是255.255.255.0就说明ip地址中前3个字节都是网络地址，最后一个字节是主机地址。如果掩码是255.255.0.0，那就说明ip地址中前2位都是网络地址，后2位是主机地址。
也就是说如果属于同一个网络地址下的不同主机之间就可以不需要通过外网进行联通了。
默认网关gateway, 网关设备是连接两个不同网络的设备。网关的作用是实现两个网络之间进行通讯与控制。网关地址就是网关设备的ip地址。网关就是内网和外网的关卡。网关的作用就是负责把内外的包发到外网。
dns域名解析，虽然一个主机找另一个主机是通过ip找的，但是如果想和谁通信都要记住它的ip就太麻烦了，就类似电话号码一样，我们想和谁打电话就必须要记住这个人的电话号码，这样太麻烦，如果我只要记住这个名字就可以打给他电话多好啊，所以就有了DNS域名解析，就比如，我们想访问百度，我们不需要知道百度的ip地址，我们只要知道它的域名：www.baidu.com即可，我们请求这个字符串就自动解析到百度的ip地址，就和百度通信了，比如就从百度的服务器取得百度网页界面了。此外，百度不只是一台服务器，如果只有一台服务器万亿崩了，百度不就不能登录了，所以百度有很多台服务器，这样通过DNS就能自动连接到百度的正常工作的服务器。所以dns就是域名和ip之间的解析。有了dns我们访问某个网站就不必输入该网站的ip地址而是它的网址了。
申请域名一般都是借助阿里云腾讯云等这种公司办理。
windows系统中,C:\\Windows\System32\drivers\etc\hosts, 这个hosts文件可以配置我们的dns, 但是这个hosts文件不让我们修改，可以先把这个文件拷贝到桌面上，然后开打，我们发现这个文件里面只有一个环网地址，就是localhost地址。这个文件不能修改，我们就点击文件的属性，把只读勾掉，应用，关闭。再打开文件再修改。
我们打开cmd,用命令：ping www.zhihu.com,返回知乎的ip：[111.166.22.197]
我们把hosts文件再次打开就可以修改了，此时我们再其一行写：111.166.22.197 www.baidu.com
然后把hosts文件保存，并覆盖原来系统里的hosts文件。此时我们再cmd，ping www.baidu.com，我们就发现返回的是知乎的ip地址。这种操作就是钓鱼网站的操作。首先用木马把你电脑里面的hosts文件修改了，比如把淘宝的域名对应的Ip改成自己的ip，然后做一个和淘宝相同的网站，这样你买东西就跑到这个假淘宝的网页上买了，付钱就付到钓鱼网站的账户里了。这就是域名劫持。但是现在已经不能用这个套路了，因为现在的浏览器一般都会有一个基本的校验，校验网址和ip之间的对应关系，然后返回一个警告的页面，警告'您的连接不是私密连接，www.baidu.com通常会使用加密技术来保护您的信息....'。
dns解析默认是从小到大，如果本机没有这个字符串对应的ip，就去找本机对应的网关，网关没有就去找机房服务器，机房服务器没有就去外网。全球一共有8个公网地址，我们的移动联通电信这三网用的服务器ip是114.114.114.114，所以我们配的时候也是配114.114.114.114。但是如果本地有域名就优先用本地。

#主机与虚拟机之间的三种网络连接模式
一种是桥接模式bridged, 一种是网络地址转换模式NAT。这两种模式以后都可能会用到，要根据不同的情况选择不同的模式。
桥接模式：VMWare虚拟出来的操作系统就像是局域网中的一台独立主机，它可以访问网内任何一台机器。使用桥接模式的虚拟系统和宿主机器的关系就像是连接在同一个Hub上的两台电脑。虚拟机和宿主机拥有相同的IP段，比如当前主机是192.168.8.100虚拟机就也是192.168.8.xxx。桥接模式的好处就是虚拟机和主机之间可以互相访问。但是缺点是，一般我们都会把虚拟机配置成一个固定ip,那配置了固定Ip就很可能和别人的ip冲突，因为我们绝大多数人的ip都是自动获取的，你是固定的ip就容易和别人冲突。所以桥接模式只能用于你能确定别人的ip不会和你的ip冲突，你就可以用桥接模式。
网络地址转换模式NAT,就是让虚拟系统借助NAT(网络地址转换)功能，通过宿主机所在的网络来访问公网。也就是说虚拟机就相当于是宿主机下面又接入的机器，宿主机就相当于一个交换机。所以虚拟机的ip是宿主机Ip的下层，所以和宿主机同等地位的主机如果想访问这个虚拟机是不可能的，因为访问发包都是通过网关往上寻找的，不会往下找，所以本局域网中的其他真实主机就无法和这个虚拟机进行通信。
所以NAT模式的缺点是外部主机是无法访问这个虚拟机的。但是反过来，虚拟机可以访问宿主机所在的局域网中的其他机器。所以这种模式的虚拟机只能自己用别人用不了。好处是不会出现Ip冲突。
NAT模式下的虚拟系统的TCP/IP配置信息是由VMnet8(NAT)虚拟网络的DHCP服务器提供的。
小结：桥接模式就相当于虚拟机和宿主机同时连接到一个路由器上，所以都可以访问外网。所以都拥有相同的IP段。
NAT模式相当于虚拟机先连接到宿主机，宿主机再连接到路由器上。所以虚拟机相当于宿主机下面的一个分支，或者说是宿主机下面的一个子网络。所以路由器下面的其他机器是访问不到这个虚拟机的，因为都是网上找不会往下找。

#系统软件和应用软件
系统软件是和硬件打交道的，用来屏蔽应用软件和硬件之间的差异。所以应用软件要基于对应的系统软件。
系统软件就是操作系统，目前电脑的操作系统主要有3个平台，第一个是windows家族的操作系统。第二个是苹果系的mac操作系统，第三个是linux家族。linux操作系统主要用于服务器。但是linux操作系统还分为两大分支。
第一个分支是收费的redhat, 一个是免费的debian。这两个分支完全不一样，debian就类似于Linux中民用的操作系统，是带界面的，就是有良好的视窗界面的。而redhat主要是用于服务器，没有界面。这两个分支的文件、后缀等都是不一样的。
debian操作系统中优秀的代表作是ubuntu,无班图，是视窗界面良好的linux系统，一些主流的应用软件都支持ubantu系统。
redhat操作系统中优秀的代表作是CentOS,无视窗主要是针对服务器的。redhat的服务是收费的，但产品是免费的，所以centos是免费的，是开源的，所以有centos社区可以随意提bug，这样redhat就可以低成本的不断推出linux各个迭代的版本。所以我们学linux主要就是学centos。如果我们要在centos操作系统上按照mysql,我们最好就按照基于redhat操作系统的mysql。
#Linux下载
当然是下载redhat下面的centos。
登录linux官网：https://linux.org/
点击download linux,  点击centos, 进入Download CentOS Linux ISO images
ISO表示镜像。此外，操作系统不能用太新的版本，因为新出的版本还没有人提bug,所以稳健起见用稍旧一点的版本，此外，操作系统的版本选择是选双不选单，因为单的是测试版，双的是稳定版。
点击Tree就进入镜像网站，因为如果我们从美国下载这个按照软件就太慢了，于是中国有很多linux镜像服务器，比如很多大学就会创建这种镜像服务器。
点击isos/, 进去后有个：x86_64/  的文件夹，表示是64位操作系统。
点击x86_64/  ，进入后有：CentOS-7-x86_64-DVD-1810.iso    ，  DVD表示家用版的正常安装。这种版本用得最多。
CentOS-7-x86_64-DVD-1810.torrent  ， torrent表示种子的意思，就是可以通过这个种子进行下载，可以用迅雷下载。
CentOS-7-x86_64-Everything-1810.iso  ， everything表示所有的组件，就是所有的组件都安装了。
CentOS-7-x86_64-LiveGNOME-1810.iso
CentOS-7-x86_64-NetInstall-1810.iso  ， netinstall表示通过网络进行安装。这种安装模式时候一次要安装好多台服务器的场景。这样就可以边下载边安装。
CentOS-7-x86_64-Minimal-1810.iso  ， 简洁版基础版，本次我们用简洁版，点击就可以下载了。简洁版好处是小，坏处是只有基础的功能包，有的默认的系统服务没有了，被精简了，那我们用的时候还得手动下载。
下载完毕就表示我们把centoos-7-x86_64-Minimal的镜像就拿到了。镜像下载完毕就可以点击这个镜像安装了。但是要安装这个镜像就意味着把这个操作系统安装在我们的电脑的硬件上了。但是安装到我们电脑的硬件上了我们就无法使用现在的操作系统了，而linux操作系统又是无界窗的，我们总不能所有操作都用命令吧，所以我们自己的电脑还是需要windows操作系统的，所以此时我们给自己的电脑再安装一个虚拟机，再在这个虚拟机上安装linux操作系统。
#虚拟机的安装和配置
虚拟化技术可以更好的利用计算机闲置的资源。
我们可以在计算机中虚拟出多台虚拟机帮助我们执行程序或者业务。
虚拟机在理论上和真实主机是一样的。比如硬盘就是真实主机用一半，虚拟机用另一半。
如果使用这种技术只需要安装对应的软件即可。就是使用虚拟化服务要安装一个软件，这个软件是virtual machine，下载安装软件：VMware-workstation-full-16.1.2-17966106.exe  ，点击安装。在安装的最后必要点击完成，先点击许可证，输入密钥点击输入就完成了。密钥：ZF3R0-FHED2-M80TY-8QYGC-NPKYF

安装完毕打开，有一个地方需要调。正常情况下，学大数据用的三台虚拟机需要28-29G的物理空间，所以一台电脑需要准备10G的空间，当学完后，一个虚拟机大概需要20-30G的空间，所以在'编辑'-'首选项'里面配置你的虚拟机文件的默认位置时也注意你放的地址的空间大小，要放到一个空间大一点的盘下面，不然容易出现后面虚拟机运行运行着，物理机空间满了，就无法写数据了，就会崩，所以要放到一个大一点的盘下面。

这样我们的VMware就安装和配置好了。下面我们在VMWare上创建出来一台不带任何操作系统的虚拟机，就相当于我们刚买的一堆没有操作系统的硬件。所以我们是分2步，第一步是创建一台主机(其实就是虚拟机)，第二步是给这台主机安装linux系统。
第一步：点击'创建新的虚拟机'，进入新建虚拟机向导，点击'自定义'， 点击'下一步'，点击'稍后安装操作系统'，点击'下一步'，选择linux，版本选择centos 7 64位， 点击'下一步'，虚拟机名称取basenode, 点击'下一步'，进入处理器配置，全部选1，点击'下一步'，进入内存配置，如果你的计算机8G内存就只能选择1G内存，如果你的计算机有16G内存你可以除了选择1G也可以最大选到4G，但是不管选多少最好不要低于1G。最好就是选择默认的配置。
点击'下一步'，进入网络连接模式，选择NAT，因为这样可以避免IP冲突，
点击'下一步'进入I/O控制器类型，这个不用管都用默认的，
点击'下一步'进入磁盘类型，不用管选默认的，
点击'下一步'进入选择磁盘，由于我们也没有老的虚拟磁盘所以选择创建新虚拟磁盘，
点击'下一步'进入指定磁盘容量，这里'最大磁盘大小'不要用默认的，最起码要给到100G，就给128G。不要勾选'立即分配所有磁盘空间'，因为一旦勾选就是划出这么多磁盘专门用于虚拟机，不要勾，选下面的'将虚拟磁盘拆分成多个文件'这样就是虚拟机用多少占多少空间，但占用的空间上线是128G.
点击'下一步'进入指定磁盘文件，默认即可。
点击'下一步'进入'已准备好创建虚拟机'点击完成即可。
至此一个名叫basenode的虚拟机就被创建出来了，左边就是这个虚拟机的内存(1G)处理器(单核)硬盘等配置信息。
然后我们开启这个虚拟机，点击'开启此虚拟机'
由于我们这个虚拟机没有操作系统，所以会给出一个提示信息:operating system not found.操作系统没有找到。此时我们会发现我们的鼠标没有了，因为鼠标是属于我们真实主机windows操作系统的电脑的，不属于这台虚拟机的。如果需要鼠标我们就要用ctrl+alt 鼠标就出来了，再点击ctrl+alt鼠标就进去了。
如果想关掉这个虚拟机，点击'虚拟机'-'电源'-'关闭客户机'
第二步：安装linux操作系统。
以前我们安装操作系统都是用光盘。虽然现在我们的电脑一般都已经没有光驱了，但我们现在安装的这个虚拟机是有CD/DVD的！但是它是一个虚拟光驱。我们点击我们的虚拟机的光驱，进入'虚拟机设置'里面的CD/DVD, 右边的'使用ISO映像文件'，路径选择就选择的是我们昨天下载的CentOS-7-x86_64-Minimal-1810.iso光盘映像文件。点击'确定'。这就相当于我们的虚拟机有一个光驱，我们给光驱里面塞了一个光盘，这个光盘里的文件就是Linux操作系统。
此时我们再点击'开启此虚拟机'，进入界面后，吧鼠标调出来，点击安装而非测试，回车，就开始安装了。
安装过程中有界面弹出让我们选择，第一步选英文，这样可以避免出现bug，比如如果选中文很可能出现乱码，点击continue, 选date&time,选asia, shanghai ，点击done.回到上一个界面，
往下滑，点击system下面的installation destination,硬盘分区。说明：windows操作系统下硬盘是分C盘D盘E盘等，Linux系统下是另外的一种文件系统，但是我们也要进行硬盘分区。选中'i will configure pattition'表示我自己去分区，然后点击done, 进入manual partitioning,点击+，弹出add a new mount point, 其中mount point选中/boot，叫引导分区，desired capacity输入256m，即256兆，点击add mount point回到manual partitioning, 再点击+, 选中swap，就是给swap空间，输入2g,这里我们一般是给内存的2倍。再点击+，选中/,就是给斜杠，desired capacity什么也不输入，就是默认把剩下的空间都给斜杠，但是我们仍能看到还剩余一点空间，这是因为这些空间是需要记录一些分区信息的，所以这些空间就不分了。
至此，我们就分了三个区，一个是boot,一个是swap，一个是斜杠。点击done,弹出summary of changes, 点击accept changes。这样分区就分好了。
再往下就是更改主机名:network & host name，点击进入，下面有个host name:我们最好改为basenode, 右边是网络连接信息，我们暂时不改，一会儿再改，点击done.
至此，我们修改了时间、硬盘分区、主机名，其中最重要的是硬盘分区和主机名，然后点击'begin installation'开始安装。在安装的过程中，界面有个root password,就是root用户的密码，我们要更改这个密码，但是一定要改成弱密码，比如123456，因为如果你的密码是你的银行卡密码，那如果别人要使用你的虚拟机就要用到这个密码，你是告诉别人还是不告诉呢。更改完点击done. ,右边的是user creation，添加用户，我们后期再添加。因为添加用户等操作我们都是后期用命令完成的，我们尽量不用界面完成。正常情况下要装1000多个包，但我们是mini版本的只要按照300个包即可。安装完毕后会显示complete, 我们点击reboot，这样操作系统就安装完毕了。点击reboot就是重启虚拟机了。重启的页面就是一个黑窗口，让我们输入用户名和密码：
basenode login :root
password:123456
这样就进入了我们linux系统里面了。
linux操作系统的界面就是一个黑窗口，是没有其他视窗界面，因为对于服务器来讲，它是不需要界面的，只要帮我们跑服务就型了，如果有视窗界面的话还需要多占内存。
这样我们虚拟机和操作系统就算是安装完成了。输入用户名root，密码123456就进入系统了。
后期linux操作系统使用主要是记忆几十个命令，创建命令是入门级的，后期的调一些系统设置的命令需要记住，比如权限、网络、进程、后台执行等等。这是一个高级程序员必备的技能。

如果是公司场景下，公司一般不会给我们用虚拟机，公司直接用的就是实体机器。只是我们不可能再买一台机器，所以我们都安装的是虚拟机。这里我们回忆一下虚拟机和宿主机之间的连接：第一种是桥接模式，虚拟机和宿主机是在一个局域网里面的平等的主机，所以ip段是一模一样的。第二种是NAT模型，宿主机就相当于一个路由器或者交换机，虚拟机是在宿主机下面的一层ip地址。我们现在使用的是nat模式。所以我们现在要配置网络，就相当于我们新买了一个已经安装操作系统的电脑，我们现在要配置电脑的网络。我们在windows系统下更改电脑的网络配置，是一步步点击进入的，然后更改ip等，这实际上也就是更改windows操作系统里面的一个配置文件。所以linux系统下配置电脑网络也是要先找到这个配置文件然后再更改就完成了配置。
第一步：查看自己虚拟网卡地址：点击'编辑'-'虚拟网络编辑器'-vmnet8
说明：看我们的vmware安装成功没有另外一个标志就是:在我们的windows系统下进入网络连接页面，看有没有VMware Network Adapter VMnet1和VMware Network Adapter VMnet8图标，如果没有就是你的vmware没有安装成功。如果没有安装成功只能是卸了重新安装，重装还不行，建议你的电脑再重新安装一个稍微正版一点的windows操作系统。
第二步：修改网络配置信息：命令是：vi /etc/sysconfig/network-scripts/ifcfg-ens33   ，回车进入一个文件里面
说明：敲命令的时候我们要用tab键这样可以自己输入一些字段，比如ifcfg-敲tab键就会自动补齐后面的ens33,如果不能自动补齐说明前面的输入是错的。
第三步：命令敲完敲回车进入这个页面，我们现在要修改这个页面里面的内容，修改这个页面的内容就要学会使用vi编辑器，以后会具体去学。现在只要完成操作即可。
先按上下左右键页面里面的光标就会上下移动，把光标移到UUID=4446ec99-4a28-4e09-9611-6f78e4362fc2,按两次dd键，就会把这行删除了。
再把光标移动到BOOTPROTO=dhcp这行，我们现在要修改这行，按I，然后把dhcp删除改成static,就是将动态分配改成静态的，因为如果是动态的，我们的虚拟机每次启动都是自动获取ip,我们想配置一些服务，Ip都不知道就没法配，所以要改成静态的。
然后再把光标移动到最后：ONBOOT=no, 把no删除改为yes.
然后再把光标移动到最后的下一行添加：IPADDR=192.168.188.100  
然后再把光标移动到最后的下一行添加：NETMASK=255.255.255.0
然后再把光标移动到最后的下一行添加：GATEWAY=192.168.188.2
然后再把光标移动到最后的下一行添加：DNS1=114.114.114.114       #域名解析里面讲过为什么是114.
说明：做这些配置的时候不要有很多自己的想法，因为没有用，说让你怎么改你就怎么改，你不听话就会出错，当别人都开始敲命令了，你就会出现网络问题，然后再花力气去查问题改问题，这样得不偿失。
然后光标回到文档的最后面：-- INSERT--， 按esc, 就删除了insert。那怎么保存？输入:wq 按回车就保存了。这里切记不要用ctrl+s,这里的ctrl+s是锁屏的意思，如果锁了怎么解锁屏幕？按ctrl+q
这样我们这个配置文件就改变了，改变后需要重启我们的网卡。
第四步：重启网卡重新加载配置文件, 命令是：systemctl restart network.service
首先我们先看一下我们的IP地址，用命令：ip addr, 回车，
我们再ping www.baidu.com, 返回的是 name or service not known, 就是找不到这个服务
那我们再systemctl restart network.service, 回车
现在我们再ip addr,回车，就会发现返回的多了一个ens33:......., 这就是我们的网卡的地址，网卡的地址就改为了192.168.188.100，后面的/24是24位的意思，再后面的192.168.188.255是广播的地址，所以我们的ip地址千万不能设置成255.
现在我们再ping www.baidu.com,就ping通了，这样就说明我们联网了，我们的网络通了。
如果还是没有ping通，我们就需要再次输入我们的文件命令进入文件：vi /etc/sysconfig/network-scripts/ifcfg-ens33
然后检查这个文件有没有哪里错误，继续修改。修改完后输入:wq 按回车保存。再重启：systemctl restart network.service
再看ip addr, 再ping百度。如此循环更改直到成功。

至此，我们的虚拟机的网络就通了，如果网络不通后面我们安装软件、通过主机控制虚拟机等操作就做不了。

网络配置通了，下面我们就开始配置计算机的防火墙。
防火墙是保护本机的端口不被别人访问。如果端口需要被别人访问到，需要添加端口的防火墙例外。
正常情况下我们是要添加防火墙例外，但是现在我们要把防火墙关掉。因为后期我们要开的端口太多了，如果每次安装了软件都要记得开启某个端口的话，就会比较麻烦，把防火墙关掉后，所有的端口都可以被访问到。这样在做项目搭环境的时候就不会有防火墙的问题，或者端口被禁止访问的问题了。但是在真实环境中我们还是不会把防火墙关掉的，因为这样还是很危险的。
所以禁用防火墙也就是关闭防火墙有两种模式：一种是临时禁用的。临时禁用是在本次虚拟机开机范围内关掉防火墙，当我们重启虚拟机的时候防火墙就又开启了。命令是：systemctl stop firewalld  ,就是本次服务内关闭防火墙。
一种是长久被禁用的。就是我们现在关闭了防火墙，但是电脑没有重启，我们现在就还有防火墙，当下次我们开启计算机的时候防火墙就是关掉的。命令是： systemctl disable firewalld， 就是禁用防火墙服务。
先用命令：systemctl status firewalld  回车，就返回一堆，其中有 active (running)，说明防火墙正在运行中，
再用命令：systemctl disable firewalld  回车，我们发现防火墙的状态依然是active (running),这个意思是下次电脑开机时防火墙就会关掉，本次服务内依然是开启的。
再用命令：systemctl stop firewalld  回车，再敲命令：systemctl status firewalld, 就返回inactive(dead)，就是防火墙关掉了。后面网络部分会讲如何添加防火墙的端口例外。

除了配置防火墙外，我们还需要配置安装软件的限制。

比如我们的windows操作系统下，我们在安装软件时经常会弹出一个框问：是否允许程序执行的提示，或者说，软件来源不清，存在风险，是否要继续安装等提示。为什么要提示？因为如果软件来源不正，或者说你的软件是一个盗版的，软件很可能会对操作系统有一定的损坏，所以，操作系统对未知软件的安装有可能拒绝或者警告，所以linux系统也是对我们安装其上的软件有一个大致的校验，如果一个软件来路不正，这个操作系统有可能直接不让安装。但是我们学习中的好多软件都是我们自己装的，所以我们要把操作系统中安装软件的控制取消掉，就是我们需要禁用这个功能。
软件安装的限制有三个级别：第一，enforcing模式，就是强制模式，在 Enforcing 模式中， SELinux 被启动，并强制执行所有的安全策略规则。第二，警告permissive, prints warning instead of enforceing。在 Permissive 模式中，SELinux 被启用，但安全策略规则并没有被强制执行。当安全策略规则应该拒绝访问时，访问仍然被允许。然而，此时会向日志文件发送一条消息，表示该访问应该被拒绝。第三，直接禁用disabled。在 Disable 模式中，SELinux 被关闭，默认的 DAC 访问控制方式被使用。对于那些不需要增强安全性的环境来说，该模式是非常有用的。例如，若从你的角度看正在运行的应用程序工作正常，但是却产生了大量的 SELinux AVC 拒绝消息，最终可能会填满日志文件，从而导致系统无法使用。在这种情况下，最直接的解决方法就是禁用 SELinux，当然，你也可以在应用程序所访问的文件上设置正确的安全上下文。需要注意的是，在禁用 SELinux 之前，需要考虑一下是否可能会在系统上再次使用 SELinux，如果决定以后将其设置为 Enforcing 或 Permissive，那么当下次重启系统时，系统将会通过一个自动 SELinux 文件重新进程标记。关闭 SELinux 的方式也很简单，只需编辑配置文件 /etc/selinux/config，并将文本中 SELINUX= 更改为 SELINUX=disabled 即可，重启系统后，SELinux 就被禁用了。

命令：vi /etc/selinux/config  就打开了etc下面的selinux里面的config文件。然后把这个文件里面的:SELINUX=enforcing改为：SELINUX=disabled, 改完之后按esc，然后按:wq  ,这样我们就修改完并退出了。
说明：这里的命令也是用的是vi, 因为基本上改东西用的命令都是vi，
前面我们修改网络配置信息的命令就是：vi /etc/sysconfig/network-scripts/ifcfg-ens33 

至此我们就更改了网络、防火墙、selinux三方面的配置。改完之后我们就可以关掉计算机，关计算机有2种，第一种是菜单栏里面有一个两竖的红竖，点击进去有'关闭客户机'和'挂起客户机',挂起就是保存当前计算机的内存状态，当我们下次重启计算机的时候就直接恢复到现在这个状态。第二种是用命令的方式关闭，敲：poweroff , 或者敲 shutdown -h now 回车，就立马关闭了。
关机完后，我们要拍摄一个我们现在当前状态的虚拟机。因为以后我们还要敲很多命令更改很多文件，如果以后更改错了，计算机出现问题了，我们想返回到现在的状态就不好返回了，只能卸载重装，所以我们现在要拍摄一个当前的计算机。
拍摄快照：在vmware的界面的左侧，右键点击basenode-快照-快照管理器-当前位置-拍摄快照-名称填写centos76,描述写：修改网络、关闭防火墙、软件安装检查。点击拍摄快照，就多了一个时钟一样的图表。当我们的计算机用了一段的时间之后，系统出现问题了，我们想回到现在的状态，我们就点击这个时钟一样的图表，点击'转到'计算机就回到快照时的状态了。
说明：拍摄快照的时候一定要关机。如果是开机状态下拍摄快照时，一些文件，尤其是一些线程文件，在内存中是会发生变化的，此时拍摄的快照就是一些临时变化的文件。所以一定要关机拍照。

虚拟机的克隆：
如果我们一个项目中需要3台这样的虚拟机，如果我们是一台一台虚拟机慢慢安装就太慢了。此时，我们进入快照管理器点击要克隆的虚拟机的一个状态，再点击克隆，下一步，点击'现有快照'，下一页，进入链接克隆和完整克隆，下一步，完成。
说明：链接克隆只保存不同的配置，链接克隆的新的虚拟机是链接在母体虚拟机上，如果母体虚拟机被删除，那和它链接的克隆版虚拟机就也不能用了。完整克隆就是重新克隆一个完全新的，新克隆的虚拟机和母体虚拟机没关系。所以链接克隆用的空间小，完整克隆用的空间大。
以后我们创建虚拟机基本上都是使用克隆，因为手动构建太慢了，如果我们以后学大数据要用到3-5个节点，就要克隆3-5个。如果我们想删除克隆的新的虚拟机，点击新的虚拟机右键点击'移除'，但是这样移除只是从控制单移除了，其实这个文件还没有真正的删掉，要去c盘找到这个新的虚拟机的文件夹(c盘文档里面的virtual machine文件夹里面)给删除才是彻底删除。
如果我们完整克隆了一个新虚拟机allnode，我们点击开这个新虚拟机，我们发现启动后显示的还是basenode,原因是我们完整克隆过来的虚拟机还没更改名字呢，这个名字不是我们取的allnode，而是从机器的iP文件以及它的hostname文件看的，我们克隆过来ip都是一样的，所以还是basenode. 同时hostname文件里的用户名还是basenode所以也要改hostname文件。再重启才能把名字改成allnode.
我们输入root用户名，输入123456密码，敲命令ip addr, 我们发现ip还是192.168.108.100， 所以我们现在开始改ip,命令是：
vi /etc/sysconfig/network-scripts/ifcfg-ens33 回车，进到修改网络的文件里面了，把IPADDR=192.168.108.100改为192.168.108.101(修改文件的某行就是：敲i, 光标就到这行的末尾，敲backspace键就删除了你想删除的字符，然后敲101,就修改了 )，然后 :wq就保存了。之后再敲命令重新加载这个新文件：systemctl restart network.service ， 再敲命令：ip addr, 就发现现在Ip就变了，但是现在还是虚拟机的名字还是basenode,  我们就再修改,用命令: vi /etc/hostname,回车，打开就是就还是basenode,我们把它改成allnode, :wq保存，回到命令行重启，输入命令exit, 回车，就是allnode虚拟机用户名登录。用户名root,密码123456，就进入allnode虚拟机了。关机：shutdown -h now
说明：etc就是配置文件的意思，所以我们上面的更改一般都是在etc目录下。
说明：虚拟机是可以拷贝的，如果我们想拷贝同事的虚拟机，我们可以把他的虚拟机整个拷贝下来，然后放到我们自己的目录里面，然后通过'打开虚拟机'选择路径打开他的虚拟机(就是.vmx那个文件)用即可。

#虚拟机本地连接工具xshell +xftp
由于我们现在的虚拟机打开是一个小黑窗口操作起来非常不方便，所以我们就需要一个工具，这个工具有可视的界面、丰富的交互，把这个工具连接到虚拟机上，而我们通过这个工具去操作虚拟机就非常方便了。
其中有一个工具叫putty软件可以帮我们连接我们的虚拟机。百度putty，进入putty:  a free SSH and Telnet client, 点击download it here.下载安装即可。安装完毕打开输入basenode的ip地址就进入basenode这个虚拟机了，比如输入命令：vi /etc/profile,回车，就看到etc下面的所有的文件了。
说明：putty这个软件只是帮助我们发送命令，如果我们basenode是关闭状态的，这个putty就链接不上了，所以用这个软件的时候要先把basenode虚拟机开开放到那里，然后我们在putty里面输入命令就可以操纵basenode了。
说明：FTP就是负责传输文件的。
putty这个工具交互效果也不是那么好，所以这里我们推荐的是xshell+xftp

#xshell安装
安装文件是：xshell_5.0.0553.exe,  双击安装文件安装。
说明：xshell最新版本都是7了，但是从6开始就开始收费了，为了收费强制用户只能开4个窗口，学大数据的话开4个窗口是远远不够的，所以是一个bug。
点击'下一步'， 选择'免费为家庭/学校'，点击'下一步'
选择接受协议条款，点击'下一步'
安装路径自己可根据情况选，点击'下一步'
进入选择程序文件夹，默认即可，点击'下一步'
进入选择语言，选择chinese simplified, 点击'安装'， 完成后就可以运行了。
xshell运行后，第一步：点击'工具'-'选项'-'更新'， 里面默认写的7天更新一次，把这个复选框勾掉即可。
第二步：'文件'-'属性'-'外观'-'配色方案'和'字体'等自己随意调。
第三步：使用这个xshell软件，用命令：ssh 192.168.133.101  ,回车， 弹出对话框选择'接受并保存', 用户名输入root, 密码输入123456， 点击确定就进来了。
输入命令：ll /etc   回车，就打印出来很多文件而且还有颜色的区分。
输入命令：clear
以后我们就用xshell了。除了xshell我们还需要再装一个xftp,因为我们有时要把windows上的文件传到linux上，就要用到这个软件，这个软件是专门用来传文件的。

#xftp安装
安装文件是：Xftp_5.0.543.exe  ，双击安装，下一步，免费版， 下一步，接受，下一步，更改安装目录，确定，下一步，下一步，中文，安装，完成。
运行，此时我们要把xftp链接到我们的虚拟服务器上了：点击左上角 '小方框右下角带个小加号'，进入'新建会话属性'-'常规'， 主机填'192.168.133.100' 即虚拟机basenode的ip, 点击'确定'，点'连接'这样就连接上了。
如果没有连接上对方的主机，用下面方法：当我们安装xftp时，这个软件会默认和xshell是集装在一起的，所以点击快捷栏里面xshell图标后面的那个像个小眼睛的图标，就默认连接到一起了。界面就是左边是windows系统的文件，右边是192.168.133.100主机的根目录/root, 我们就可以直接用鼠标把windows里面的文件拖拽到右边即可，就是把windows里面的文件发送到linux里面了。
此时我们再打开xshell，用命令ll, 查看有没有刚才拖拽过来的文件，就会发现有了。
后期我们使用Linux的时候，我们就是把linux开一下机就放那里就行了，登录也不用登录。然后我们再开个xshell，在xshell里面操作linux,这样就方便很多。这和我们的mysql一样，我们把mysql服务器开开，在另一台电脑里面开一个navicat连接到mysql服务器，操作navicat即可。
小结：xshell和xftp就是一个方便我们使用linux服务器的一个工具。现在我们的xshell和xftp都是连接的是我们本地的虚拟出来的服务器，以后工作中我们会连接到比如阿里云的服务器或者我们自己搭建的服务器。

#linux命令学习策略
linux学习的基础包括环境的搭建、工具的安装等。现在我们已经用xshell工具连接到linux操作系统上了，现在我们就开始学如何操作linux，也就是学Linux的一些命令。linux命令有上千个，而且每个命令还有很多参数，所以我们不会全部学，只学一些基础的简单的，比如类似window系统那样，打开文件夹、关闭文件夹、移动文件夹、重命名文件夹，有时手动改一改Ip地址、操作一下防火墙、添加一个用户、删除一个用户等基础操作。一般我们不回去修改windows注册列表等这种管理型命令的操作。
#Linux命令的规范
linux命令与参数之间必须用空格隔开。#A
linux命令是区分大小写的
A：比如vi就是命令，后面的路径etc/sysconfig/network-scripts/ifcfg-eng33就是参数。再比如：ls -a  也是命令和参数之间加一个空格区分。

如果我们敲一个命令返回 command not found ,那么要么是命令错了，要么就是你敲的命令的软件没有安装。
比如我们在cmd命令窗口里面敲ipconfig回车就出来windows电脑的网络端口配置情况，但是我们在linux系统里面敲ifconfig就报command not found,就是因为我们linux安装的是一个mini版本的，就没有安装ifconfig这个包，要安装了这个包才能运行这个命令。所以在linux系统下我们用ip addr  命令来查看网络配置。ficonfig其实就是显示和修改网络接口的ip地址。
再比如我们敲一个命令：yum search ifconfig，它会帮我们查一下ifconfig这个包在什么位置，并且帮我们更新一下相关库，返回matched: ifconfig, 这是一个basic network tools,这个工具在net-tools.x86-64包里面。
所以说只有我们安装了ifconfig这个包，我们才能用这个命令。

#linux命令的类型
有些命令是我们系统自带的，有的命令是我们后期安装的，有的命令是关键字、有的命令是一个脚本等等。比如：
type cd, 返回：cd is a shell builtin 
type ls, 返回：ls is aliased to 'ls --color=auto'  , aliased表示别名假名的意思。意思就是我们只要敲一个ls就等于我们敲了 ls --color=auto 这句代码，就会自动帮我们标记一个颜色。
type for, 返回：for is a shell keyword， 意思就是for是shell的一个keyword.
type ping, 返回：ping is hashed （/usr/bin/ping), 意思就是ping是一个脚本，这个脚本放在根目录下的usr下的bin下面的一个ping文件。
我们查看一下这个ping文件：vi /usr/bin/ping ,返回一大堆看不懂的符合，看不懂也是一个文件。
clear就把前面敲过的命令返回的结果都删除了，可以重新开始输入命令。
小结：我们的命令类型大致有4种，第一种是内置命令，第二种是命令的别名，第三种是命令可能是一个关键词，第四种是命令可能是一个文件。

#帮助文档
命令：help cd, 会打开cd的帮助文档，change the shell working directory 更好shell的工作目录，也就是切换目录，所以cd命令是用来切换命令的。
help ping, 返回：no help topics match 'ping',try 'help help' or 'man -k ping' or 'info ping'
infor ping,返回好几百页！敲q键返回。
man ping, 返回 send ICMP ECHO_REQUEST to network hosts ,意思就是发送一个包到我们的主机地址。
小结：如果是内置命令，我们用help ,如果是外部命令我们用man.
如果我们的Linux没有man包，我们的man ping 也会报错，此时我们需要手动安装man包：
yum install man man-pages -y  ,安装上就可以用man命令了。
说明：shell是linux四个主要部分之一，实际上shell就是一个命令解释器。工作中遇到linux命令不动的就百度。比如我们不知道linux的ping命令就百度：linux ping 就会有很多帮助手册，帮助文档。ping就是检测主机的。

linux的命令有：文件管理类、文件传输类、文档编辑类、系统管理类、系统设置类、网络通讯类、磁盘管理类、磁盘维护类、备份压缩类、设备管理类。共几千个命令。

#常用命令
#  whereis 查询命令文件的位置
whereis ping  #查看Ping命令在哪里,就是找Ping文件的目录。
返回：ping: /usr/bin/ping /usr/share/man/man8/ping.8.gz
whereis cd, 返回:  cd: /usr/bin/cd  usr/share/man/man1/cd.1.gz   , 即cd文件的目录
ll,  查看当前目录下有哪些文件

#  file 查看文件的类型
file /usr/bin/cd  返回：/usr/bin/cd：POSIX shell script, ASCII text executable ,意思是这是一个shell的脚本。
file /usr/bin/ping  返回一堆，意思是它是一个ELF 64-bit的文件，版本是version1,动态链接接口是多少，是基于linux 2.6.32的内核
file /usr/bin/yum ，返回：/usr/bin/yum: python script, ASCII text executable, 意思就是一个Python的脚本。

#  who 查看当前在线的用户
who, 返回：root  tty1   2021-11-29  ,意思就是现在root在登录这个系统。
假如我们再创建一个用户：
useradd libai
passwd libai
123456
123456
然后我们把linux系统关了，重新启动。启动好了要输入用户和密码，输入libai, 123456, 就是libai这个用户在登录这个linux系统。此时我们再敲命令who，就返回的是libai
whoami , 返回libai, 就是问我是谁
pwd ， 返回：/home/libai   ,就是问我在哪儿

#查看主机内核信息
uname -a ， 返回内核信息

#打印: echo 类似于sout syso ,打印语句
echo hello,  就返回一个hello, 就是打印出一个helloe
#  clear  清屏
#   history 查看一下我们敲了哪些命令，就是敲命令的历史，就返回我们上一个clear后的所敲的所有命令。
如果我们不想让别人查看我们敲的历史命令，用： history -c  ,  再敲history  就返回1个历史就是history. 此时我们再用上下键就不行了，因为我们把历史清空了。

说明：当我们用root用户登录linux的时候命令提示符是#加一闪一闪的，说明root用户是管理员权限，此时我们可以创建libai这个普通用户。如果我们是libai这个普通用户登录linux的，我们的命令提示符就是$加一闪一闪的，此时如果我们想创建一个baijuyi的用户：useradd baijuyi, 就会返回permission denied, 表示请求被拒绝，也就是说你的权限被拒绝，就表示普通用户是没有创建用户权限的，也表示普通用户是没有权限调用useradd这个命令的。

#特殊字符
.  ,如果一个文件名的开始以点为起始，就说明这个文件是一个隐藏文件
命令ll，返回的是非隐藏的文件，如果命令ll -a , 就返回很多文件，其中就有点开头的隐藏文件。
ll -a /root， 返回root目录下面的所有文件，包括隐藏和不可隐藏的文件。
ll -a /etc， 返回etc目录下面的所有文件，包括隐藏和不可隐藏的文件。
ll -a /etc/sysconfig ,返回sysconfig目录下面的所有文件，包括隐藏和不可隐藏的文件。
这两个命令返回的都是各自目录下面的所有文件，其中 .文件表示root目录本身，..文件表示/根目录，就是root的上一层目录。所以，点表示当前路径，点点表示上层路径。

# $  
这个符号表示一个变量， $PATH Linux 的环境变量
比如：name=liqingzhao ,就是把字符串liqingzhao赋给变量name, 如果我们调用name把它打印出来，用echo $name ,就打印出来liqingzhao , 如果我们echo name, 就打印出的是name.

#*  星号， 代表的是通配符
ll /etc/a*  就表示找到etc目录下面的以a开头的所有文件。
ll /etc/*d  就表示找到etc目录下面的以d结尾的所有文件。

#~ 波浪线
cd /etc , 光标就返回到：[root@allnode etc]# 光标，  root是管理员用户，也是当前用户，@是分隔符， allnode是主机名， etc是你现在所在的路径，#表示root用户是有管理员权限的。
cd /etc/sysconfig , 返回[root@allnode sysconfig]#光标， 意思就是当前路径，是个相对路径，如果我们要查看sysconfig这个路径的全部，就用：pwd, 就返回：/etc/sysconfig  , 就是我现在在的绝对路径。
cd , 回车返回：[root@allnode ~]#光标，这样就返回的是波浪线这里了，这里波浪线表示的是家目录。
家目录就类似于windows中的 c/用户/25584 , 就类似于'用户'文件夹下面的文件夹，比如我在'用户'下面再创建一个lyy文件夹，就好像又创建了一个用户一样。
不同用户的家目录不一样，超级管理员root的家目录在/root下面，普通用户libai的家目录在/home/libai
[root@allnode ~]# pwd , 返回：/root
[libai@allnode ~]# pwd , 返回：/home/libai

说明：/斜杠是整个linux文件的根目录

# -和--
ls --color=auto 返回：anaconda-ks.cfg
说明一个杠-是在简写的情况下用，--在完整的单词的情况下用。也就是说-用在简写，--用在完整的单词。

#Linux文件系统
文件系统指的是操作系统是如何管理文件的。不同的文件系统存储文件的方式是不同的。文件是存储在磁盘上的。所以，windows系统是把磁盘划分为C盘D盘F盘等盘符，我们是通过盘符进行查找和访问文件的。这样设计的好处是找文件简单明了，缺点是：如果别人的一个程序在你电脑上跑，但你的电脑连盘符都没有就没法跑了，直接报错了。此外，这种设计不好扩容，比如C盘满了，没法扩容，只能把系统先卸载再分盘再安装系统。
而Linux系统是没有盘符的，它用的是一个文档目录树模型。linux中的文件组织方式是通过维护一个树状结构的文件模型，linux中的所有文件都是通过这个文件树来访问的。这个树模型只有一个根节点就是斜杠，每个节点上可以有多个子节点。也就是根目录斜杠下面有多个文件夹。

#文件系统和挂载策略
如果斜杠下面的文件已经占满存储空间了，此时我们可以再买一个硬盘比如一个T的硬盘，然后把这个硬盘挂载到斜杠下面的某个文件夹下面。先把硬盘插到电脑上，然后用命令mount把这个硬盘挂载到你想挂的路径上即可。这就是树模型文件管理系统的优点，扩容方便。最多可以挂载65536个磁盘。
挂载磁盘的命令：
mount /dev/disk1 /usr/download    #意思就是在/usr/download上挂载一个1T的硬盘disk1
disk1 1T
mount /dev/disk2 /usr/upload   #意思就是在/usr/upload上挂载一个100T的硬盘disk2
disk2 100T
mount /dev/disk3 /usr/upload/photo  ##意思就是在/usr/upload/photo上挂载一个1P的硬盘disk3
disk3 1P
此外，linux上运行的程序如果在别的电脑上跑，出现目录问题的话，我们可以随时创建一个树目录，这样程序就可以继续跑了，不存在没有盘符的问题了。
说明：安装了Linux系统后，一般系统都会在根目录斜杠下面生成一些文件夹，这些文件夹叫二级目录，斜杠是一级目录。我们程序员在创建自己的文件夹的时候一般都是创建一个三级目录下面的文件夹，最好不要创建和更改二级目录。因为二级目录都是系统默认的，而且每个名字都有它的涵义。我们要做到见名知意。
查看二级目录的命令：ll /  就返回所有的二级目录
bin目录：表示可执行文件，一般都是放一些命令、脚本都放在bin目录里面。
boot: 引导分区，就是我们服务器启动的时候，或者说linux启动的时候，有个引导程序在boot里面。
dev: 指的是设备信息
etc：指的是系统配置文件。如果我们以后打开一个文件夹，发现里面有一个文件是etc,就说明是它的配置文件目录。这个目录就相当于windows中的c盘里面的window文件夹里面的system32文件夹里面的东西，都是一些系统配置文件。
home: 家目录。是普通用户的家目录。就相当于windows里面的'用户'文件夹，里面不同用户有不同的文件夹。
lib: 类库。我们执行一些程序是需要类库的。
lib64：64位的类库。
media: 多媒体的一些东西。
mnt: 挂载区。硬盘挂载的时候默认的都是挂载到这个文件夹里面。比如U盘就挂在这个文件下面，插上就可以用。
opt: 在linux系统下我们一般默认软件安装目录是opt下面。opt下面一般放的都是我们自己安装的软件。所以以后我们自己安装软件的时候尽量往opt里面安装。但是，在windows操作系统中我们安装软件一般都是默认按照在program files,或者program files(x86)里面，这些都是我们自己安装的软件，如果是一些系统软件(比如说公司的OA系统、财务软件等)的话，window一般会默认在'用户'下面的文件夹里面。
proc:  进程信息。不是线程。
root：root用户的家目录。超级用户的家目录。上帝用户的家目录。
run：运行时的一些系统变量。是一个临时文件系统，存储系统启动以来的信息。
sbin: 管理员可执行的一些权限和命令。sbin就是super bin 的意思。
srv: 该目录放一些服务启动之后需要的一些数据和变量。
sys: 系统的内核信息。
tmp : 这个目录是用来存储一些临时文件。比如我们计算过程中会产生一些中间变量，当计算完成时这些中间变量将被舍弃掉。没舍弃之前就存在这个文件夹里面。这个文件夹里面的数据在我们电脑重启后有可能被清空掉。
var :也是用来存储一些临时文件的，只是这里面的变量不会重启清空。所以比如我们要保存一些日志信息我们就最好放到var里面。如果有些东西用完就不用了就放tmp里面。
usr : 就相当于好多用户共享的一个用户区域。好多应用软件就会默认往这个目录里面装，它就类似windows里面的c盘里的windows文件夹。usr里面的文件会被sys分掉一部分。

此外，window上的文件存储路径字符串中的斜杠是往右撇的，Linux里的文件路径字符串中的斜杠是往左撇的。

万事万物皆文件。在linux中所有的东西都是由文件构成的，包括它的线程都是由文件构成的，也包含系统进程都是由文件构成的。所有的一切都是以文件的方式进行操作的，所有的一切都是通过文件来进行管理的，所以文件的路径有相对路径和绝对路径。绝对路径是以根目录为起点查找其他文件，相对路径是以当前的路径为起点去查找其他文件。但是如果是一些配置文件，尽量写绝对路径。
.点代表当前路径，..点点代表上层路径。
查看系统进程命令： ps -ef 就打开了系统进程，linux的系统进程就相当于windows中的任务管理器，任务管理器中有很多进程。正常情况下进程是在内存中运行的。但是在linux系统中它是借助于文件，那这些进程文件在哪里？
命令：cd /proc/  #进入根目录下面的proc文件夹查看进程文件
命令：ll ， 返回当前目录里面的所有文件和文件夹
命令：echo $$   返回：7053， #查看当前进程编号，说明当前客户端正在使用的进程就是7053
命令：cd 7053    #进入7053文件夹
命令：ll , 返回7053文件夹里面的所有文件。这些文件就是我们当前环境运行中所涉及到的全部变量。

小结：linux系统可以扩容，所以linux里面安装的东西要比windows要多得多，而且linux不会出现没有盘符的情况。linux里面万事万物皆文件，所以我们操作一切都要回归到文件上去，包括更改网络信息、更改防火墙信息、更改软件安装信息等都是通过操作文件实现的。后期我们学大数据的一些框架也是更改这些信息。此外linux的二级目录要熟记，因为这几乎就是行规，比如hdoop的配置文件就叫etc, 它的可执行目录就叫bin或者sbin.

#linux文件操作的命令
1、cd  改变当前工作目录，就是切换目录。
先pwd看看我现在在哪儿，如果返回/root表示我们根目录下面的超级管理员用户目录下面。如果返回/表示我们在根目录下面。如果我们在其他目录下面，我们就敲命令cd 就进入到'根目录下面的超级管理员用户目录'，就是/root, 我们敲cd /,再敲pwd就返回一个斜杠表示我们在根目录下面。我们再敲cd ../etc就进入etc目录里面了。这种是从相对路径进入的，就是从当前目录的上层目录里面去找etc文件夹。

2、ls  或者 ll ：显示当前文件夹下的所有文件。
ll呈现的方式是一行一个文件，ls呈现的方式是一行好几个文件的形式呈现的。
ll一行一个文件呈现时，前面的字符串表示文件的类型和权限，-表示这是一个文件，d表示是一个文件夹，l表示链接，类似于windows里面的快捷方式。
命令：type ll  ,返回：ll is aliased to 'ls -l --color=auto'
当我再次敲命令：ls -l --color=auto， 返回的东西和ll -a命令下返回的结果是一样的。所以说我们敲命令ll和敲命令ls -l --color=auto是一样的。

命令：ll -a  #显示当前文件夹下面的所有文件，包括隐藏文件。

3、创建文件目录：mkdir
回到超级管理员的家目录里面：cd 回车即可，再用pwd查看一下返回/root，说明已经返回到家目录了。
现在我们在家目录里面创建一个新文件夹叫aaa ： mkdir aaa , 然后ll，就返回家目录里面有一个aaa的文件夹。
在家目录里面创建一个文件夹a，a里面再创建一个文件夹b,b里面再创建一个c：mkdir -p a/b/c  , ll发现家目录里面多了一个文件夹a，再cd a 就进入a文件夹，ll, 就发现a里面有一个文件夹b, 再cd b 就进入b文件夹，ll, 就发现b里面有一个文件夹c.
如果我们敲 mkdir -p /a1/a2/a3 就表示我们在根目录斜杠下面创建了一个文件夹a1,再在a1里面创建a2,再在a2里面创建了a3文件夹。
小结：当mkdir -p 目录参数，  当目录参数写的a,就表示在当前目录下面创建文件夹a，如果写的/a就表示在根目录下面创建文件夹a，是一个绝对路径。
同时创建多个文件夹：mkdir -p shiren{libai,baijuyi,dufu}，就生成三个文件夹，名称分别是shirenbaijuyi,shirendufu,shirenlibai.
如果敲：mkdir -p shiren/{libai,baijuyi,lqz} ,就表示在当前目录里面创建了一个文件夹叫shiren,这个文件夹里面有三个文件夹是libai, baijuyi,lqz.
小结：花括号相当于起到一种并列的关系。

4、删除文件：有5种命令：rmdir 文件夹名，  rm 文件名，  rm -r 文件名，   rm -f 文件名， rm -rf 文件夹名
如果家目录里面有个空文件夹aaa, 要删除aaa, 用命令：rmdir aaa 就可以删除，但是如果rmdir shiren就报错，报rmdir: failed to remove 'shiren':Directory not empy,说明文件夹不空就不能删除。所以rmdir要求删除的文件夹必须是空文件夹。并且rmdir只能删除空文件夹不能删除不空文件夹也不能删除文件，一个文件不是文件夹rmdir也不能删。
如果家目录里面有个文件yum.conf, 要删除，用命令：rm yum.conf, 返回提示是否要删除，输入y，删除。如果用rm aaa不行会报aaa是个文件夹。
rm -r 文件夹名，返回提示是否要删除，输入y，删除。
rm -f 文件名，就是强制删除不用再输入y等对话。
rm -rf a   #把文件夹a删除了。rm -rf 文件名  ,是可以删除文件夹和文件的，文件夹不空也是可以被删除的，这个命令是强制删除的意思，也是不用输入y等对话。

5、文件的操作：复制cp、剪切、修改文件名、创建文件。
5.1  复制cp
ll /opt  #查看二级目录opt里面的所有文件，我们发现返回的是0，就是我们还没安装任何应用软件呢。
我们家目录下面有一个文件：anaconda-ks.cfg文件，我们把这个文件拷贝到opt里面：
首先先回到家目录：cd  ， 然后拷贝：cp anacnda-ks.cfg /opt
cd /opt   , ll , 就发现opt里面也有anaconda-ks.cfg这个文件了。
如果我想把etc文件夹里面的一个文件yum.conf拷贝到家目录里面：cp /etc/yum.conf ./  就可以了。
小结：cp的语法就是：cp 源文件 目标地址
如果想把一个文件夹shiren,shiren下面还有三个子文件夹，要把shiren拷贝到opt里面：cp -r shiren /opt  这样才能把不空的文件夹拷贝到另外一个地方。
也可以用 cp -r shiren* /opt  就把当前目录下面所有以shiren开头的文件夹就都拷贝到opt里面了。
小结：cp命令拷贝普通文件就直接拷贝，如果要拷贝文件夹就要加一个-r

5.2 文件的移动，即文件的剪贴
把家目录里面的yum.conf文件剪贴到opt文件夹下面：
进入到家目录里面敲命令： mv yum.conf /opt  ,这样家目录里面的这个文件就被移到opt里面了。
再移回来：mv /opt/yum.conf /root  ,就又移动回去了。
小结：mv 源文件 目标地址  ，这个命令不仅可以移动文件也可以移动文件夹。

5.3 修改文件名，也是用mv命令
比如想把家目录下面的yum.conf文件名改为yum1.conf，命令是：mv yum.conf yum1.conf  即可
更改文件夹的名称也一样的命令。

6、创建一个文件 touch
前面讲的mkdir libai是创建一个文件夹，现在这个touch libai是创建一个名称为libai的文件。
touch libai libai2  就是创建了2个文件，一个叫libai, 另一个叫libai2

7、查看一个文件的属性(或者说查看一个文件的状态) stat
stat命令就类似于windows操作系统里面的文件，当我们点击这个文件的属性时，就弹出一个属性窗口，这个属性窗口的所有信息都是用可视化的形式呈现的。而linux系统中的stat命令也是类似显示一个文件的所有信息的，只是linux呈现的方式不是窗口化的形式。
stat jingyesi  返回的一堆信息，这些信息就是jingyesi这个文件的所有信息，其中：
file:‘jingyesi’表示文件的名称。
size：0表示文件的大小是0字节。
block是块的意思。
IO Block: 4096  ，表示磁盘的分配，一般我们是分配4k,4k就是4096， 1k=1024字节
device: fd00h/64768d  ,表示硬盘在哪个驱动下面。
Inode: 134346588  ,这个参数表示的是：一个文件的绝对定位。因为名字叫jingyesi的文件不仅可以在当前的目录下面也可能其他目录里面也有名叫jingyesi的文件。这是都叫jingyesi名称的文件会不会混淆，不会的，不会就是因为inode这个属性不同，这个属性就是区别不同文件的，即使两个文件叫的名称相同它们的inode是不同，就区别出来了这两个名称相同的文件了。inode这个属性类似于主键的性质，就是一个文件的名字可以随便更改但它的inode是不能随便换的。inode也就是这个文件在硬盘中存储的位置。这个文件名字可以随便叫，但它在硬盘中位置不变。
links:1 ,表示静态的硬链接的数量, 就是指有多少个快捷键指向这个文件所在的硬盘的区域。
access:（0644/rw-r--r--）, 表示这个文件的权限
Uid: (  0/   root) ，表示所属用户
Gid: (  0/   root) ，表示所属组
Access:  2021-12-04 04:45:47.892164673 +0000
Modify: 2021-12-04 04:45:47.892164673 +0000
Change: 2021-12-04 04:45:47.892164673 +0000
这三个时间第一个access表示谁什么时候访问过这个文件。此时我们vi jingyesi ，进入这个文件的编辑状态，我们什么都不编辑直接就退出，此时再查看stat jingyesi，我们会发现access的时间变了，所以access就是访问的意思。
第三个change时间表示文件的权限发生了变化，这个属性就类似于windows里面的文件的属性里面的'只读'等文件权限，如果我们此时敲命令: chmod a+x /jingyesi ,这个命令就是更改文件的权限，此时我们再查看stat jingyesi，change时间就更改了。
第二个modity时间是什么时候修改过文件的内容。此时我们 vi jingyesi, 敲一点内容，然后保存退出，再stat jingyesi 我们就会发现这三个时间就都改变了并且变得一样了。那是因为我们改变了文件的内容就相当于访问过这个文件了、也更改了这个文件的内容了、也改变了源文件的模式了。所以三个时间都相等。

8、文件的链接 ln
'链接'对应到windows上就类似于快捷方式。在linux系统里链接分软链接和硬链接。
8.1软链接：软连接也称为符号链接。
我们先创建一个文件：touch qiangjinjiu
编辑qianjinjiu: vi qiangjinjiu  ,编辑完后保存。
查看这个文件：cat qiangjinjiu, 就返回我们上面编辑的内容。
ll查看这个文件，这个文件前面显示的是：-rw-r--r--
现在我们给这个文件创建一个软链接：ln -s qiangjinjiu slink    #-s表示软链接，qiangjinjiu表示要链接的文件，slink表示链接的名字。
此时我们再ll查看这个文件，我们发现这个文件显示变成了lrwxrwxrwx , slink ->qiangjinjiu ，这里前面的首字母l表示链接的意思，slink指向了qiangjinjiu,就是qiangjinjiu这个文件有一个快捷键，这个快捷键的名字叫slink,这个快捷键指向的是qiangjinjiu这个文件。
此时我们 cat slink  , 返回的也是qiangjinjiu文件的内容。
说明：文件的链接就相当于windows里面的，比如，我们的QQ程序，QQ这个文件安装完毕后会在桌面或者开始菜单栏里面有个QQ图标，这个QQ图标的本质就是QQ程序文件的一个软链接，当我们点击这个软链接的时候也就相当于我们点击了QQ程序的文件名，就是调用了QQ程序文件，就执行这个文件，就打开这个软件了。也就是说当我们安装QQ文件的时候，虽然我们选择的安装路径是比如C盘某个文件夹下面，没有安装在桌面或者开始菜单的地址下面，但是我们安装完毕后桌面文件夹和开始菜单里面也有QQ图标，这就是因为我们安装的时候自动给这些目录下面建立了一个软链接，而这个软链接指向的是真实QQ文件安装的地址(C盘某个文件夹下面)。这种就是软链接。
8.2硬链接：
硬链接和原始文件指向文件系统中的同一个文件。如果害怕一个文件被误删，你可以使用硬链接保护这个文件。
命令：ln qiangjinjiu hlink  #hlink表示hardlink就是硬链接的缩写。
此时再ll, 返回了一个 -rw-r--r--  hlink  的文件，这个文件就不像软链接中有一个指向的标志。
此时再 cat hlink ,也返回qiangjinjiu的文件内容。
此时我们更改一下hlink这个文件:vi hlink  ,内容加一句qianjinsanjinhaifulai.  保存。
此时我们再cat hlink, 再cat qiangjinjiu , 再cat slink， 都返回的是已经又编辑过的内容。
此时我们删除qiangjinjiu这个源文件：rm -rf qiangjinjiu
再ll, 我们会发现slink这个文件变红了，报错了。此时我们再cat slink 就报no such file or directory, 我们cat hlink这个文件就正常显示文件的内容。
小结：当我们的源文件出现问题了，比如被删除了，那么我们软链接的文件就也会出现问题，但是我们的硬链接文件就不会出现问题。为什么？
再举一个例子说明为什么：
vi jingyesi     #创建一个jingyesi的文件,并且在文件里面写入chuangqianmingyueguang.
ln -s jingyesi sjys   #创建一个软链接的文件，这个文件名字叫sjys,  B
ln jingyesi hjys   #创建一个硬链接的文件，这个文件名字叫hjys,  C
stat jingyesi     #查看源文件的属性
stat sjys    #查看文件sjys的属性
sta hjys    #查看文件hjys的属性    D

A：创建文件是touch，但是用vi 一个文件，如果这个文件不存在就直接生成一个这个文件名并且打开这个文件。
B：这个软连接文件不是jingyesi文件里面的内容，只是一个链接文件，就是这个文件只是个指向文件不是jingyesi里面的chuangqianmingyueguang的具体内容文件。
C: 这也就是为什么hjys文件前面用的是：-rw-r--r-- 说明它是一个正常的文件不是链接文件，比如上面的例子： -rw-r--r--  hlink 。不像软链接文件里面有一个指向的符号，比如上面的例子：slink ->qiangjinjiu
D：通过查看属性我们发现，hjys的inode和jingyesi的inode一样，而sjys的inode和jingyesi的inode不一样。这说明文件sjys存储在硬盘中的位置和jingyesi存储在硬盘的位置不一样，当我们调用sjys这个文件时，这个文件是一个链接文件，就是说调用它时，它就自动把链接指向了jingyesi这个文件的文件名，然后jingyesi文件名再指向chuangqianmingyueg这个文件内容在硬盘中存储的位置。
而文件hjys的内容在硬盘中存储的位置inode就和jingyesi文件内容在磁盘中存储的位置inode相同。就是说chuangqianmingyueguang这个存储在硬盘中的内容同时被jingyesi名字和hjys名字指向，也就是这两个名字同时指向chaungqianmingyueguang这个块磁盘里面的内容。所以为什么hjye的inode和jingyesi的inode一样，而软链接的不一样。
此外，除了inode这个参数外，我们还发现stat jingyesi返回的links是2，stat hjys返回的links也是2，stat sjys 返回的links是1。这说明磁盘里面的这个块儿区域(就是inode表示的区域，里面的数据内容是chuangqianmingyuegguang)它对应的链接有2个，而文件sjys对应在磁盘的区域(内容是一个指向的内容，也就是一个链接的内容)只有一个链接。所以当我们调用sjys时我们调用的就是一个链接内容，这个链接内容是连接在jingyesi这个文件名上，jingyesi这个文件名再指向chuangqianmingyueguang这个内容上。而当我们调用jingyesi和hjys名字时就会直接指向chuangqianmingyueguang这个内容上。所以当我们删除jingyesi这个文件时，正常情况下是把jingyesi这个文件名和磁盘中的chuangqianmingyueguang都删除了，但是由于chuangqianmingyueguang在磁盘中有2个links，也就是由于磁盘里面的内容chuangqianmingyueguang有2个links，2个links表示有2个'引用'指向这个inode。所以我们删除jingyesi就只是删除了一个名字而已，这个名字对应再磁盘里面的内容不会被删除，因为内容还有一个引用指向呢，所以不能删，所以只是删除了一个名字。所以jingyesi这个名字被删除了，sjys文件里面的链接对应的链接名字就被删除了，所以sjys文件就出现错误了。而硬链接文件hjys就不会出现问题。这也是为什么我们害怕别人删除我们的文件时，我们最好给这个文件创建一个硬链接而不是软链接，这样别人删除的不是这个文件的内容而仅仅是删除了要给文件名，我们的文件内容在磁盘里面还是好好的，没有缺失。
说明：不管是软链接还是硬链接，在使用的时候都要用绝对路径，否则可能出现问题。
小结：inode就是文件内容在硬盘中存储的位置。这就是值调用和引用调用。这就是指针和引用。所以硬链接和源文件是指向磁盘中的同一个文件，不是在磁盘中多复制出一份源文件。这样做的好处就是减少磁盘占用量，节省资源。此外硬链接有时是我们故意去保护某些文件不被恶意删除，如果源文件被别人恶意删除了，那我们还可以通过硬链接找到这个文件。

前面讲的都是文件的创建、复制、链接等，现在要深入文件内部
#查看文件内容：
把前面的hjys文件名改为shudaonan : mv hjys shudaonan   即可
把shudaonan里面的内容从chuangqianmingyueguang改为nanyushangqingtian:  用vi 编辑，编辑完保存即可
查看shudaonan文件： cat shudaonan , 返回nanyushangqingtian，显示文件的内容是从前往后的顺序显示的。
查看文件内容还有另外一个命令：tac shudaonan, 如果这个文件有很多行，这个命令返回的文件内容是从后往前显示的。
如果我们要查看一个内容很长的文件，就是有很多行的文件，如果我们用cat和tac命令，它们都是显示整个文件的，这样看大文件很不方便，而且很占内存。所以我们会分页查看文件内容：more shudaonan  , 此时我们按'回车'就开始逐行显示，当我们想再看看前面的内容就敲 b(back的意思) , 就返回到按回车前的位置了。如果此时我们按'空格'就会一页页地显示。如果我们不知道这些快捷键，敲 h ，就返回快捷键的用法。再敲q 就退出了文件内容的显示。
除了用more shudaonan 查看文件内容，我们还可以用less shudaonan查看，理论上less命令比more命令更强大，但是我们一般认为这两个命令都差不多。

除了cat , tac, more , less 查看文件内容外，有时我们只想看一个文件的前N行或者后N行：
显示文件的前5行：head -5 shudaonan
显示文件的后5行：tail -5 shudaonan

当我们出现报错的时候会说你的某个文件的第多少行出现erro了，那我们就想查看一下这个文件的第某行，那就用命令：比如查看第8行： head -8 shudaonan | tail -1   就只显示第8行。
说明：这里的竖杠 | 表示把前面head -8 shudaonan查询的结果传给后面，以后竖杠|使用的频率是非常高的。tail表示从后往前取多少行。

tail 除了可以从后往前取文件的内容外，还可以监控文件的变化：
比如我们ping 百度一下，我们希望把ping百度的日志数据放到一个文件中，就用命令：
ping www.baidu.com >> baidu    #意思就是把ping百度的数据添加到文件名为baidu的文件里面。
然后ctrl + c， 退出添加。然后再ll查看当前目录下面的文件，我们就发现多了一个文件baidu, 我们再cat baidu, 或者more baidu等等命令都可以查看baidu这个文件里面的内容，就是ping baidu的一些日志。

说明:现在我的电脑上面没有安装xshell ，如果我们安装了xshell，我们就可以在xshell的窗口点击小加号'+'，弹出窗口输入 ssh 192.168.133.101 表示再启动一个allnode虚拟机，就是同时启动两台allnode虚拟机，然后输入用户名root,密码123456，就启动了。此时我们将第一台allnode一直运行命令：ping www.baidu.com >> baidu
然后在第二台allnode上查看baidu这个文件。在第二台allnode上我们ll查看文件，我们会发现每次ll一次，baidu文件的大小都会变化，那是因为第一台allnode一直在追加日志所以每次ll查看都发现文件baidu一直在增加。此时我们在第二台allnode 上敲命令：tail -f baidu, 就会发现这个文件的内容在一条条增加，就是只要第一台allnode的baidu文件夹里面放入一条日志，第二台allnode中的baidu文件在tail -f baidu这条命令下就动态打印一条条日志数据。如果此时我们再开启第三台allnode虚拟机，然后敲命令：tail -F baidu ,就也是动态呈现一条条打印的日志数据。此时我们再开启第四台allnode虚拟机，同时我们把第一台allnode的ping www.baidu.com >> baidu命令停止下来(ctrl +c即可)，此时我们发现第二台allnode的baidu文件就也停止追加打印了，第三台allnode的baidu文件也停止追加打印了。此时我们在第四台allnode上输入命令：rm -rf baidu ,就是删除了baidu这个文件。此时我们查看第三台allnode就会出现提示：tail : 'baidu' has become inaccessible: no such file or directory.但是第二台allnode就没有这个提示。此时我们在第四台allnode上再生成一个同名文件： touch baidu, 并且在这个文件的末尾追加打印一行hello字符串：echo hello >> baidu  ,此时我们看第二台allnode就发现baidu这个文件没有任何变化。而第三台allnode出现了一个行提示：tail: 'baidu' has appeared; following end of new file, 然后在下一行显示hello打印的字符串。所以，同理，如果我们此时在第一台allnode再启动ping : ping www.baidu.com >> baidu 这条命令，第三台allnode就会继续打印这个日志，而第二台allnode不会继续打印。也就是说F那台虚拟机就可以继续监控日志信息，而f就停止监控了。
小结：这个知识点是读取新增数据，如果我们用tail -F 文件名 ， 的话，它会监听指定名字的文件，如果这个文件被删除了又重新创建一个一模一样的名字的文件，它会重新监听新文件的数据变化，监听不受影响。如果用tail -f 文件名 的话，它会监听inode的文件数据变化，但当文件被删除后即使再创建一个名字一样的文件，inode也会发生变化，于是监听就失败。总之：f监控的是inode, F监控的是文件名。当我们删除监控文件时，监控文件的links是1，所以文件的名字和文件内容inode都被删除了，此时f和F都就监听不到了。如果此时我们再新建一个同名文件，但是这个同名文件的inode和之前的文件的inode一定不一样了，所以f就监听不到了，F还可以继续监听。所以以后我们要监控某个文件的话，要根据自己的情况去监控，如果我们想监控某个文件的inode，我们就用tail -f 文件名，如果我们想监控某个名字的日志文件就用tail -F 文件名，这样当这个文件被删除了，我们也可以再创建一个同名文件继续监控。一般工作中我们都是监控文件名，就是用F监控。因为比如工作中我们要生成一些日志文件，但是我们一般不把这些日志放到一个文件里面，一般都放好几个文件里面，也就是迭代的生成一些日志文件，比如这个日志文件是今天的，那个日志文件是昨天的等等多个文件，此时我们用F就比较方便。

#文件的搜索，就是如何快速定位一个文件
如果是windows系统的话，我们可以安装一个比如everything等的一个工具软件就可以快速搜索。而linux系统我们用命令：find /  , 这表示全局搜索，就是在所有文件夹里面搜索。
find / -name sjys  就返回sjys这个文件的路径。如果我们敲命令find /etc -name sjys 就什么也没有返回，就表示etc下面没有sjys这个文件。当我们搜索/etc时不仅会看etc下面有没有文件sjys，也会去搜索etc下面的文件夹里面的文件看有没有sjys。
find /etc -name a*a  #找一个以a开头以a结尾的文件。
find / -name hadoop*  #在根目录下找以hadoop开头的文件。

#vi编辑器
在linux中万事万物都是文件，既然是文件我们就要学会对文件进行编辑，而编辑文件就要学linux里面自带的一个软件，叫vi编辑器。类似于windows系统里面的记事本软件，但比记事本要强大的多得多。仅vim的命令也就是vim的使用技巧就可以编写一本很厚的书，可见其功能之强大。比如京东的《vim使用技巧》一书就100元靠上，而java界的《java编程思想》才80元左右。可见vi非常强大，仅仅是一些命令就是一厚本书。它的强大还在于它把键盘上任何一个键都做成了快捷键，而且它还有组合键，牛。
除了vi编辑器我们还听说过vim，vim可以说是vi的升级版，就是类似于notepadd和记事本一样，但是它们二者是兼容的。所以我们先学vi，学完vi，vim的基础就学完了。

#打开一个文件：
首先我们先在/etc 文件夹里面找到profile这个文件：cd /etc  ;  ll -a找到这个文件
然后把这个文件复制到/root目录下: cp profile /root
再回到/root, 打开这个文件： cd ;   vi profile  这样就打开了profile这个文件的全部内容。
如果这个文件的第8行报错了，我们只想查看这个文件的第8行：vi +8 profile  回车，就发现我们把profile全部打开了并且光标已经定位在第8行了。
vi + profile , 就打开文件并且光标定位到文件的最后一行。
如果我们发现profile文件里面一个单词if写错了：vi +/if profile   就打开Profile并且光标定位到第一个if上面，此时我们敲n(next)，光标就自动往下定位下一个if ,直到文档结束。

#vi编辑器的三种模式：
模式1：编辑模式， 此时按dd就删除了一行， 按p就粘贴出来一行， 按100p就粘贴100行。此时键盘的每个键都是快捷键，就是每个键都有其他功能，此时的模式就是编辑模式。
此时按i键，就进入模式2：输入模式，输入模式下键盘的每个键是什么就是什么不是快捷键，你按哪个键就是写出哪个字母。这就是输入模式。此时我们再按esc，就又回到编辑模式。
此时我们再按:冒号，就进入末行模式，也叫底行模式，也叫命令行模式，这行就相当于文件的状态模式，此时我输入set nu  回车，就把所有的行标了一个行标。也就是在末行模式下，我们可以输入一些命令调整文件的状态属性。
小结：当我们vi 文件名  就打开了这个文件，这个文件一被打开就处于编辑模式，可以通过上下控制光标的位置，此时我们敲i(insert)键，这个文件就进入输入模式，此时文件的最后有个--INSERT--,这是我们可以写东西删东西等操作，此时我们再esc文件就处于编辑模式，我们把光标移到我们想移的地方敲a(append)追加的意思，此时文件的最后就又出现insert字样，这是我们就可以随意写入内容和删除内容了。
如果我们想在文档的某一行的下一行再添加东西，正常情况下是光标调到某一行的最后一个字母，然后按a，进入insert模式，然后按回车就进入这行的下一行了。我们也可以将光标调到某一行的任意位置，然后按o就进入下一行的输入模式了。
小结：快捷键i 是在前面添加的意思。快捷键a是在后面添加的意思。快捷键I,大写i就是在行首插入。快捷键A就是在行末追加。快捷键o是在下一行插入。快捷键O大写o是在上一行插入。
小结：当文件处于编辑模式时我们输入:冒号就进入末行模式，末行模式下按esc就进入编辑模式。编辑模式按下上面的任意快捷键就进入输入模式，输入模式下按esc就进入编辑模式。输入模式和末行模式是不能直接切换的。

#编辑模式的一些快捷键：
1、定位光标：
在编辑模式下输入15gg， 就将光标直接定位到第15行了。
再按gg，光标就默认跳到第1行的开头， 如果按1000gg光标就跑到最后一行的开头。
再按gg光标跑到第一行，按shift g 就是G光标就跑到文档最后一行。
上下键可以将光标定位在一行的行首或者行末，左右键可以将光标在左右一个个字母移动。而w键可以让光标一个单词一个单词的移动。
按j光标就下，按k光标就上， 按h光标就左，按l光标就右。这样我们就不用上下左右键盘了。
shift+6 光标就跑到这行的行首，shift+4光标就跑到行尾。
pgup, pgdn是一页一页翻文档。
2、删除一行：
光标放到某行的任意位置，然后编辑模式下dd键就删除了这行
如果要删除多行，光标放在起始行的任意位置然后编辑模式下10dd就是删除了10行。
如果要删除某个单词就用dw键。删除多个单词用比如3dw，就是删除3个单词。
3、复制粘贴：
光标放到某行的任意位置然后yy就是拷贝了这行，然后pp就在这行的下行粘贴了这行。
光标放到某行的任意位置然后3yy就是拷贝了3行，然后2pp就在光标的下行粘贴了2个这3行。
yw是复制一个单词，3yw是复制3个单词，然后2p就粘贴6个单词。
4、撤销上一步操作：u
如果一直u 直到文件底部出现 already at oldest change
如果要返回撤销操作用.点。
5、保存文件
当我们不管是编辑模式粘贴复制了文件还是输入模式写入了东西，我们进入编辑模式下按shift zz, 就保存了更改后的文件并退出了。
小结：
G:光标定位到文档的最后一行的开头
gg：光标定位到文档的第一行的开头
5gg: 光标定位到文档的第5行开头
w：光标定位到下一个单词
5w: 光标定位到下5个单词上

dd: 删除光标所在的行
3dd: 删除光标所在的行以及这行下面的2行。
dw: 删除一个单词
5dw: 删除5个单词

u: 撤销前面的操作。
. 点：回退u执行的操作

yy：复制一行
3yy: 复制3行
yw: 复制一个单词
3yw:复制3个单词
p：粘贴
3p: 粘贴3次
x: 剪切
3x: 剪切3个字符

r : 替换，然后输入字符替换即可， replace的缩写。
3r: 替换3个字符。

方向键：j下，k上， h左， l右。
大写ZZ：保存文件并退出。
ctrl+s锁屏， ctrl+q解锁。

#末行模式
1、保存并退出
当我们处于编辑模式时，按：冒号就进入末行模式，然后敲w就保存了文档。也就是编辑模式下敲:w，就是保存了，这种保存方式就类似于我们编辑记事本文档的时候中间会时不时的点击'文件'菜单里面的'保存'按钮，就是临时保存文件的。
当我们敲:wq 回车,就是保存并关闭的意思。这类似windows下记事本文件点击保存再点击x关闭。
当我们打开文档并有所修改文档的内容，此时我们想不保存退出文档：:q! 。这就类似于windows系统里面的记事本文件打开修改后直接点x，不保存修改就关闭。！感叹号就是不保存强行关闭。如果我们输入:q它会提示你没保存就要关闭？所以你再敲命令:q!就不保存关闭了。
说明：如果上次文件出现异常退出，系统会保留同名隐藏文件，每次启动会给与提示：如果确定当前文件没问题，请删除隐藏文件。意思就是比如你打开了一个文件，文件名是profile, 然后你改改改里面的内容，但后来改崩了，就是你也不知道改哪里了，也不知道怎么改了，最后你想放弃修改这个文件，但是此时你已经改了很多东西，此时这个文件你想退出都不能正常退出了，于是你直接关机式的退出，然后你再开机再打开这个文件，就会报attention,found a swap file by the name '.profile.swp'....巴拉巴拉一堆，.文件名表示这个文件是隐藏文件，swap是交换的意思，就是一个隐藏的交换文件，然后你每次打开profile文件都会提示你这段话，如果嫌麻烦我们直接删了这个隐藏文件rm -rf .profile.swp ,就不会再弹出这个提示了。
2、添加文档的行号：set nu
3、删除文档的行号：set nonu
4、查找与替换
小结：
w: 保存
q: 退出
wq: 保存并退出
q!强制退出，但是不保存。

#vim
由于我们现在装的系统是minimal版本的，所以当前系统里面还没有vim , 如果想用vim,现在安装：
yum install vim -y     #自动安装完毕
此时我们再vim profile, 就会发现这个文件有高亮显示。其他用法和vi是一样的。

#计算机间的数据传输
之间我们说的计算机之间的数据传输指的都是两个电脑之间的信息传输，而这里我们说的是两种系统之间的数据传输。这里指讲windows和linux之间以及linux和linux之间传输，不讲windows和windows之间的数据传输是因为我们都会呀，比如QQ, 微信就都是windows和windows之间的数据传输。
#window--linux
用xftp, 在xshell界面上点击xftp按钮，就进入xftp窗口，在这个窗口中拖到即可，或者点击右键-'传输' 即可
如果我们电脑没有安装xftp怎么办？用linux命令：
首先，要按照一个软件：yum install lrzsz -y     #rz表示上传，sz表示下载
安装完毕后敲：rz  , 就弹出一个windows的窗口里面你选择路径把windows里面的文件传到linux.
敲：sz profile  就把linux系统下的profile文件传到windows系统下的桌面上了。
#linux--linux
首先我们要有两台linux操作系统的电脑，然后才是两台电脑之间的数据传输。这时我们可以用之前讲过的克隆方法，再完全克隆一台虚拟机。克隆完毕后启动，用root用户和123456登录，登录上后要更改这台虚拟机的名称、网络：
hostname node1
vi /etc/hostname   进入文件后，dd, i , 删除basenode,改为node1
vi /etc/sysconfig/network-scripts/ifcfg-ens33  ,进入文件后更改 ipaddr
systemctl restart network.service   #重启网络配置文件
ping www.baidu.com  #查看网络是否通
启动xshell , 输入命令： ssh 192.168....你的ip地址， 让两台虚拟机都连着xshell
然后在虚拟机basenode的当前目录里面创建一个文件basefile, 和一个文件夹base, base里面有文件夹01,01里面有02文件夹，02文件夹里面有03文件夹：
touch basefile
mkdir -p base/01/02/03
现在我们把文件basefile拷贝到node1的虚拟机：scp basefile root@192.168.... :/opt/   
说明：scp是拷贝，basefile是要拷贝的文件也就是源文件，root@192.168.... 是对方虚拟机的地址，就是要拷贝到的目标地址，:冒号后面是要拷贝到哪个目录下面，这里是拷贝到node1虚拟机的根目录下的opt文件夹下面。
此时敲回车就问你你是否要和node1建立链接，敲yes, 然后再弹出对话框让你输入对方机子的密码，因为不能随便在别人机子上粘贴文件，所以要输入密码，输入123456，回车，这样就拷贝过去了。
当我们拷贝文件夹的时候，把base文件夹拷贝到node1上： scp -r base root@192.168.... :/opt/  

如果我们想把node1电脑里面root目录下面的baidu文件拷贝到现在操作的这台电脑(basenode):
scp root@192.168...:/root/baidu /opt   , 这样就把别人电脑node1里面的文件拷贝到我们自己的电脑basenode里的opt文件夹里面了。
同理，拷贝文件夹也是上面的命令但是要加一个-r

小结：
scp：把源数据地址source拷贝到目标数据地址target
我们现在讲的相互传输数据是要输入密码的，以后讲怎么相互免密钥。

#文件目录所占空间的大小
就是类似于windows操作系统中某个文件夹点击属性可以看到这个文件夹所占多大的空间。linux系统中对应的命令是df和du。其中df表示查看分区信息。
敲命令df,就返回dev设备信息，boot引导分区信息，tmpfs临时文件系统，，等等分区的信息。
命令: df -h, 返回的和df命令一样的信息，区别就在于一个用字节表示一个用M和G等单位的表示。

查看一个指定文件的大小：du
du -h
du -h --max-depth=1
du -h --max-depth=1 /etc   #就把etc文件夹下面的深度只有1的文件全部显示，并且显示它们都有多大。
du -h --max-depth=1 /   #就把根目录下面的深度只有1的文件全部显示，并且显示它们都有多大。
说明：proc文件夹里面的东西都是关于进程方面的东西，而进程方面的东西都是可变的，所以就算不出来大小。
说明：swap是一个特殊分区，以硬盘代替内存。当内存使用满的时候，可以将一部分数据写出到swap分区。

#文件解压和压缩：
在linux系统中有两种文件压缩方式，一种是tar,另一种是zip  。比如文件tomcat的压缩包就是apache-tomcat-8.5.47.tar.gz  ，一般情况下在linux系统下的压缩包都是.tar.gz  , 在windows里面好多都是zip, 现在技术不断发展linux系统里不管是tar.gz还是zip压缩包现在都可以解压缩，只是用的命令不同：
解压tar包：tar -zxvf apache-tomcat-8.5.47.tar.gz   #zx是解压的意思，v是过程的意思，f是文件的意思
就把这个文件给解压出来了，解压出一个apache-tomcat-8.5.47的文件夹。
压缩文件命令：tar -zcf tomcat.tar.gz apache-tomcat-8.5.47      #将上面解压后的文件再压缩，压缩后的文件名为tomcat.tar.gz, 这里面文件的后缀不能写错、参数的位置也不能写反。这样就在当前目录下面多了一个压缩文件。

zip 压缩， unzip解压
用zip和unzip命令都要手动安装：yum install zip unzip -y
压缩文件：zip -r tomcat.zip apache-tomcat-8.5.47  #第一个参数是压缩后的文件名，第二个参数是要压缩的文件
，这样当前目录下面就多了一个tomcat.zip的压缩文件。
解压文件：unzip tomcat.zip

以上都是linux的文件命令，下面讲linux网络信息。
小知识点：当我们开启2台或者多台虚拟机的时候，只要在vimware上打开即可，然后在xshell里面运行这些虚拟机的命令。此时，我们点击xshell的最左边的小+号图标，进入'新建会话属性'对话框，在名称里面填'allnode',协议默认SSH, 主机填allnode的ip地址：192.168.133.101， 端口号默认22，然后点击'链接'。此时在xshell的工具栏的第二个快捷键就是小文件夹的图标后面有个小三角符号，点击这个小三角符号就自动链接上allnode了。同理把basenode也加上。这样就可以快速链接了。

#linux网络命令-修改主机名称
主机名称的修改可以有临时修改和长久修改。
临时修改：hostname school     #表示把主机名改为school, 此时再敲回车，我们发现还是allnode主机名，此时我们exit， 退出，重新再链接allnode的时候，我们就发现变成了[root@school ~]#
此时我们再输入命令：reboot  #重启服务器  ， 此时就重启allnode这台虚拟机了，此时我们发现还是[root@allnode ~]#
,这说明我们是临时修改的主机名不是长久修改的。
长久修改：长久修改我们就要修改配置文件，用命令：vi /etc/hostname  ,进入修改主机名的配置文件，修改保存即可。

#DNS解析
DNS解析又叫域名解析服务，就是可以将域名转换为ip地址。
ip是由网络地址和本机地址组成。子网掩码是用来区分网络地址和本机地址的。默认网关是用来发送数据的。DNS是为了把域名转换为ip地址。
windows系统下的这个文件 c:\\windows\system32\drivers\etc\hosts 就是专门用来配置DNS路径的
而在linux系统下也是有一个配置文件,配置dns路径的：vi /etc/hosts
打开hosts文件我们会发现已经有两个地址了：127.0.0.1 和 ::1  , 这两个地址就是传说中的环网地址，一个是ipv4的环网地址，一个ipv6的环网地址。就是当我们访问本机的时候也是要配置一个Ip地址去访问，一般127.0.0.1就是我们默认的环网地址，这个地址是奔着我们的主机回来的。
我们可以根据我们的需求在这个文件里面添加dns路径，比如我们添加一行：
192.168.133.101 node01 
然后保存文件，然后我们再：ping node01  ,我们就发现我们ping通了，此时我们ping的不是ip地址，ping的是node01,就是自己配置的一个名字，而这个名字node01是对应192.168.133.101这个ip地址的，所以我们ping node01就ping 的是这个ip地址。这就类似于我们ping www.baidu.com，我们ping的是百度的域名而不是百度的ip地址。我们也可以直接ping ip地址，比如ping 192.168.133.101也是一样的。但是ping域名要简单好记。

#网络相关命令
#ifconfig
查看当前网卡的配置信息。也就是查询本机的地址的。这个命令属于net-tools中的一个命令，但是centos7中没有集成这个包，所以要自己动手安装。如果没有ifconfig可以用ip addr临时代替。

当我们敲命令：ifconfig, 返回command not found,表示没有这个命令，那我们先查一下这个命令：
yum search ifconfig  , 我们发现ifconfig这个命令不存在是因为这个包的依赖包也没有安装。此时我们要安装一下：
yum install net-tools -y , 安装完毕后再ifconfig就返回了我们网卡的ip地址192.168.133.101以及我们的环网地址127.0.0.1。这样我们就用这个命令查询出来了我们的本机地址了。

#netstat
查看当前网络的状态信息。就是查看网络的状态情况。
一个机器默认有65536个端口号[0,65535]。
这是一个逻辑概念，将来我们需要使用程序监听指定的端口，等待别人的访问。
一个端口只能被一个程序所监听，端口已经被占用。

命令：netstat -anp  ，返回一堆东西，但是我们只看前面的一部分，这部分表示我们电脑的这些端口正在被别人所监听。比如第一个端口号是22端口号，我们在做ssh请求的时候，默认的都是访问22端口，所以22这个端口号默认的是ssh数据访问接口，所以22端口名字叫sshd。我们发现有三个地方的端口名字都叫sshd，那是因为一个ipv4,一个是ipv6,另一个是ip地址加端口号。所以这个命令是让我们看到我们电脑端口被监听的一个情况。

命令：netstat -r   ，显示的是我们的核心路由表route

小结：所以，netstat命令是查看我们计算机当前的网络情况的，就是计算机的端口情况的。

下面的两个命令：ping和telnet是查看我们的网络是否能连通的。
#ping: 查看与目标ip地址是否能够连通。
ping的就是对方的ip地址，也就是看和对方的网络是否能连通。比如ping node01, 或者ping 192.168.133.101 ， 返回的是发了几个包收了几个包这样的信息。就说明两台电脑在网络层上可以连通。但是如果我们要访问某些端口，是否可以连通呢？就是说虽然我们两台主机网络可以连通但是端口有可能是连不通的。所以我们要用telnet命令查看是否与目标机的端口连接上了。
#telnet
查看与目标ip的指定端口是否能够连通，所以telnet命令后是跟着要给ip地址和端口号：
telnet node01 8888  ,意思就是telnet 192.168.133.101 端口号是8888，但是这个命令不存在，是因为我们没安装相应的包：yum install telnet -y  ,安装完毕后，再telnet node01 8888, 返回的是这个端口连接拒绝了connection refused
我们再telnet node01 22  , 此时就连上了connected to node01，此时光标就自动进入下一行表示让我们输入要传输的数据，比如我们输入1234567890，回车，返回protocol mismatch，connection closed by foreign host.意思就是我们输入的数据和对方端口上的协议不匹配，然后被对方把连接关闭了。但是此时也说明我们的端口是通的，就是传输的文件协议不对被拒绝了，就是因为对方端口收到我们的1234567890这串数据，然后判断数据协议不对才拒绝的，所以说明端口是通的。
小结：ping是查看某个ip地址是否通，telnet是查看某个端口是否通，一般情况我们是先看ip是否通，ip通了我们再看端口是否通。

#curl
curl是一种restful风格的资源定位方式，就是我们所有资源在网络上都有唯一的定位。所以我们可以通过这个命令唯一定位标识指定的资源。
比如，可以直接获取对应网站资源的命令：curl -X GET http://www.baidu.com  ,这个命令就可以拿到百度的首页面，这样我们就拿到百度的首页面数据了，就是-X GET什么就获取了信息。

#防火墙
防火墙非常复杂我们不可能讲全部，这里只讲防火墙怎么用。
防火墙技术是通过有机结合各类用于安全管理与筛选的软件和硬件设备，帮助计算机网络与其内、外网之间构建一道相对隔绝的保护屏障，以保护用户资料与信息安全性的一种技术。简单的说，防火墙就是用来保护我们的端口的。我们一个计算机上有65536个端口，如果防止这些端口被别人恶意访问，就是通过防火墙，防火墙可以让这些端口开启、关闭，当关闭时外网就不能访问这个端口了，这就是防火墙的作用所在。
以前的linux系统使用防火墙是用iptables,现在centos7中使用的是firewalld.
#查看防火墙的状态
命令：systemctl status firewalld.service  , 返回的是inactive就是被禁用了。
#禁用防火墙
临时禁用：systemctl stop firewalld 或者：systemctl stop firewalld.service
长久被禁用：systemctl disable firewalld   或者：systemctl disable firewalld.service
#开启防火漆
systemctl start firewalld 或者：systemctl start firewalld.service

命令：firewall-cmd --state  , 返回not running表示没有运行。
命令：firewall-cmd --reload, 重新加载配置，比如添加规则后需要执行此命令,返回success就是加载成功。
命令：firewall-cmd --get-zones   #列出支持的zone
命令：firewall-cmd --get-services    #列出支持的服务，在列表中的服务是放行的
命令：firewall-cmd --query-service ftp   #查看ftp服务是否支持，返回no
命令：firewall-cmd --add-service=ftp    #临时开放ftp服务，返回success
命令：firewall-cmd --add-service=ftp --permanent  #永久开放ftp服务，返回success
命令：firewall-cmd --remove-service=ftp --permanent   #永久移除ftp服务，返回success
命令：firewall-cmd --add-port=80/tcp --permanent   #永久添加80端口,返回success

#开启一个端口的正确操作：
很多端口我们是要使用的，所以不让打开所有的端口是不现实的，所以这里讲如何打开防火墙：
1、先查看我们的电脑开启了多少端口：netstat -anp , 从返回看我们可以被访问的端口只有：22，25， 58三个端口。
2、现在我们要添加一个端口：
firewall-cmd --zone=public --add-port=80/tcp --permanent    #添加, 就是打开一个防火墙
现在就是把80端口添加为例外了。如果我们电脑上有mysql数据库,就要添加3306端口号，
firewall-cmd --reload     #重新载入
firewall-cmd --zone=public --query-port=80/tcp   #查看
firewall-cmd --zone=public --remove-port=80/tcp --permanent    #删除
说明：以后我们会添加好多端口的例外，所以我们就直接关掉防火墙了。尤其是我们在配置集群的时候，端口非常多，一下子就需要配置好几个端口，而且它这个端口并不是我们使用的端口，它是一些比如说内部通信端口等，是需要我们手动去打开的。

#加密算法
要加密算法是为了保护我们的数据不被破坏。比如支付宝就有很多数据库，如果支付宝的数据库管理员用u盘把数据库里面的数据都拷贝走，然后自己把账户里的钱偷偷转走。这种操作肯定是不允许的，但禁止这种做法不可能是规章制度可以做到的，是加密算法做到的。就是用加密算法把数据库里面的数据进行加密，这样就免受破坏。加密方式有3种，第一种是不可逆加密算法，第二种是对称加密算法，第三种是非对称加密算法。这三种加密算法各有优劣，就是不同场合用不同的加密算法。

#不可逆加密算法
就是原始数据经过不可逆加密算法加密后，我们是无法通过加密后的结果数据计算出原始数据的。其原理类似于：
7+8=15，而15=？+？,这我们是无法倒推出来的，因为可算解就非常多了，比如1+ -16也是等于15，这样就是有非常非常多个解，而我们不知道哪个解是原来的解。
比如我们的用户信息数据库，如果用户的用户名和密码都是以原文的形式存在数据库里面，那数据库泄露了密码就也泄露了。那我们如果保护我们密码不被泄露？我们对用户密码进行加密，让明文的密码变成密文的密码，此时密码泄露也没事。比如，我们登录支付宝输入的密码是123456，但是支付宝数据库里面存放的密码并不是123456，而是123456经过不可逆加密算法计算后的数据，就是一长串加密数据，这时用户再登录支付宝，如果用户输入的密码是123456，则支付宝的后台只要对比密文是否相同即可，只要密文相同就说明用户输入的密码就是123456，就是对的密码，就可以登录了。
所以不可逆加密算法是明文对应唯一一个密文，但密文对应很多明文，也就是密文反推不出明文。这样支付宝的数据库管理员即使知道用户的密码密文，他也是不知道明文密码是多少，他就无法登录用户账户。而且一般网站登录都设定登录次数，一旦登录次数达到3次都不对，就限制你登录了。

不可逆加密算法比较有名的有2种算法：Hash算法 和 md5算法
Hash算法常用在 不可还原 的密码存储、信息完整性校验等场景。
还可以用在文档、音频视频文件、软件安装包等用新老摘要对比是否一致，比如判断接受到的文件是否被修改。
还可以用在 用户名或者密码加密后 数据库存储，所以数据库大多数不会存储关键信息的明文，就像很多登录功能的忘记密码不能找回，只能重置。
md5是目前一种比较主流的验证文件完整性的加密算法。比如我们通过迅雷等下载软件下载一个2G的游戏，我们怎么判断这个游戏是否完整下载了？对比文件大小有点不严谨，比如在传输过程中有几个字节传错了，但文件大小是一样的。其实我们一般会计算一下这个文件的md5值，看这个文件的md5值是否和源文件的md5值一样，如果一样就是没错，不一样就是传输中出现错误了。

百度搜'在线MD5'--要加密的字符串：baijuyi--加密--返回有16位的有32位的。而且这些密文都是16进制的，如果是32位的密文，那16^32次方就非常非常大，就是说要从这个32位的密文推原文有16^32次方种解，所以就是无法回推原文的。

百度搜'在线hash'--输入'baijuyi'--选择'sha1'--点击加密，就返回密文：7b890a55edf0e3.......

小结：不可逆加密算法就是只能将明文转化为密文，不能将密文转化为明文，如果非得想看密文是什么意思，就要暴力破解，就是计算量非常大的回推，但是我们现在通常都是限制回推次数，比如您的密码连续3次输入错误就禁止登录了。意思就是你只能破解3次，3次没成功就不能登录了。而且这种加密方式，密码丢了只能重置不能找回。

#对称加密算法
不可逆加密算法，明文加密成密文后，无法破解密文，就是只能看密文而不知道密文对应的明文是啥。所以不可逆加密只能进行校验等场景。如果我们要传递消息，那需要拿到密文的人也能够知道密文对应的明文是什么，才能够传递消息。所以此时就是：明文--加密--密文--密文反编译--明文，所以这里就涉及到加密和解密两步。
对称加密算法就是使用相同的密钥对数据进行加密和解密。
比如一条明文是'今晚一教自习室见'，我们可以把这条明文先转化为拼音，再把拼音的每个字母+1进行转化，这样就变成了一条密文，此时我们再传递这条密文，即使中间被别人看到，他没有密钥，他也看不懂这条消息的内容，而消息的接收者知道如果解密，他就知道这条密文的明文是什么。类似于我们以前的密码本。
这种加密方式是密钥对信息发送者和信息接收者都是公开的，计算量小，加密速度快，密钥较短。
缺点是一是一旦一方泄露了密钥，全部的信息都将暴露，二是给不同的人传递信息要使用不同的密钥，不然大家都知道密钥，就都能解密了，所以要很多密钥。所以如果支付宝为每个用户都生成不同密钥，则密钥数量巨大，密钥管理有压力。
对称加密的代表性算法有：AES 、DES 、3DES 、IDEA、RC4、RC5等
对称加密的应用场景有传输加密、指令加密。

百度搜'在线AES'--密码比如输入123， 待加密的文本比如输入'baijuyi', 点击AES加密，就生成密文：rV7PEgwpHyy...
解密：输入密文rV7PEgwpHyy...， 输入密码123,点击AES解密，就生成baijuyi。如果我们把密码也就是密钥写错，比如写成了1234，就解不出来了。

小结：对称加密就是有原文、密钥、密文，原文可以通过密钥生成密文，密文可以通过密钥生成原文。就是只要密钥确定下来，原文就能加密成密文，密文就能解密成原文。就是加密和解密的密钥是一样的。用什么密钥加密就用什么密钥解密。

#非对称加密算法
非对称加密算法需要一对儿密钥，就是两个密钥。一个是公开密钥publickey一个是私有密钥privatekey，简称公钥和私钥。公钥和私钥生成的时候是一对儿的。用公钥加密只能用对应的私钥解密，同理，用私钥加密只能用对应的公钥解密。
优点是安全级别非常高，几乎很难破解，理论上破解非对称加密要算1000多年，缺点是加解密速度慢、密钥长、计算量大、效率低。但是据说量子计算机3分钟可以破解出来。因为量子计算机算的非常快。这里要说明的是，加密解密过程中计算量大，这个大也只是在毫秒级别，比如1秒钟可以计算1万个对称加密，1毫秒就是算出来10个，用非对称加密1秒钟可能只能算出1000个，就是1毫秒算出1个，假如我们的网站每秒的访问量都在1万，那如果我用非对称加密算法的话，就要多加10倍的服务器，所以要看网站的实时流量、最高流量、以及硬件资源(服务器)的数量来决定用什么算法。
代表性算法有：RSA, ECC, DSA(数字签名用)
RSA是非对称加密算法的典型代表，是三个人名的首字母，就是这种加密算法是这三个工程师合作研发的。
应用场景有：HTTPS证书制作、CRS请求证书、金融通信加密、蓝牙等硬件信息加密配对传输、关键的登录信息验证。
比如，连接上对方的蓝牙进行数据传输时，防止数据泄露，对方蓝牙也会提供一个公钥和私钥，我给对方蓝牙发消息时，用对方蓝牙的公钥进行加密，对方收到后用自己的私钥进行解密，数据就还原回来了。
说明：数字、字符串可以加密，文件也是可以加密的，因为文件也可以转化为二进制，只要是二进制就可以加密。

比如有两台电脑进行通信，如果中间有个路由器，就可以抓包抓住这两台电脑之间的通信内容了。这样通信过程就非常不安全，那怎么做呢？把两台电脑之间的通信数据进行加密，把加密后的数据再发包在网络上传输。
再比如我们平常登录支付宝或者京东的时候，我们登录的用户名和密码都是要在网络上传输的，传输的时候要经过我们电脑所在的局域网的路由器，再经过外网的路由器，再经过更大的外网路由器，才到达支付宝或者京东的服务器，这中间很可能会有某个路由器，这个路由器偷偷的拦截支付宝或者京东的请求登录数据包，就拿到用户名和密码了。所以，在路由器端是可以拦截我们的请求数据的，就是说从路由器上我们是可以看到哪个员工访问了哪些网站，都是一目了然的。有的路由器或者交换机还有地址过滤功能，就是屏蔽一些网站比如淘宝，这样就从内部路由器或者交换机上阻止员工工作时间登录淘宝。所以说数据是可以被拦截的，所以防止我们的数据被拦截而泄密，我们就要加密。所以很多黑市、暗网、购物网站等都需要加密技术。
但是对称加密要生成非常多的密钥对，密钥对管理难度就非常大，而且对称加密一旦密钥泄露，这些数据就没有秘密可言了，这就需要非对称加密。就是加密的密钥和解密的密钥是不同的。我们用公钥进行加密用私钥进行解密。我们把公钥暴露出去，别人给我发消息的时候就可以随意用我的公钥对消息进行加密，加密后的信息只有我自己可以看明文，因为只有我自己有私钥。这就是非对称加密。
我把我的公钥公开，对方给我发信息的时候就知道我的公钥，就用公钥对数据进行加密传给我，我收到后用私钥解密这个密文就得到信息了。
比如，我的电脑要发出一条请求登录信息到支付宝，我是先和支付宝服务器建立连接，建立连接就是支付宝发给我它的公钥，我用支付宝的公钥把我的请求登录信息加密，变成密文传输到支付宝服务器，支付宝服务器收到密文后用它的私钥解密查看我的请求信息。支付宝给我回信息时，就先请求我的公钥，我把我的公钥发给支付宝，支付宝把要发给我的信息用我的公钥加密通过互联网传给我，我收到后用我的私钥解密即可就可以查看回信了。
就相当于每个人都有一个公开的密钥和一个非公开的私钥。这个公开的密钥和不公开的私钥在生成的时候就是生成的一对儿。所以是互为公私的，就是一个是公钥另一个就是私钥，一个是私钥另一个就可以当公钥。一般情况下，我们把比较短的就是比较简单的密钥当作公钥，把比较长就是比较复杂的密钥当作私钥。

百度搜'在线RSA'--RSA公私钥生成，就是生成密钥对儿--密钥长度可选512位、1024位等，这个密钥长度是越长越安全，但计算的难度也是越长越大，--生成密钥对儿要不要通过既定的密码去生成，所以可以填整数密码，比如填123，意思就是通过123这个密码去生成公钥和私钥。这里也可以不填密码，不填就是使用默认的方式生成密钥对 --点击'生成密钥对'，就生成一对儿密钥。我们发现一般都是公钥短私钥长。--有了公钥和私钥，我们就可以加密了--点击'RSA加密解密'，输入公钥和要加密的内容就生成了密文，同理，把密文放进去，输入私钥，点击解密就生成了原文。

小结：非对称加密就不怕数据泄露，因为即使泄露也无法查看数据原文。后期我们如果学kerbors，集群校验的时候，就是集群中心授权，分布式校验的框架，通过非对称加密就可以轻松进行集群内部的数据访问。
三种加密算法各有优缺点。

#主机之间的相互免密钥
主机之间的相互免密钥就是我们以后登录其他主机的时候就不用密钥了，这是服务器集群里面很重要的一个知识点。比如如果我们有2台服务器，一台服务器崩了另一台服务器要快速接上它的工作，如果中间过程还要输入密钥，就需要人手动输入，就不能进行实时切换了。所以此时我们就需要主机之间相互免密钥的配置。
当我们打开两台虚拟机，一台是allnode, 一台是basenode, 当我们登录allnode时，我们想在allnode上操作basenode,就先要把allnode和basenode链接起来，做法是在allnode虚拟机上输入命令：ssh 192.168.133.100，然后yes，然后输入basenode的密码123456， 这样就在allnode上登录上basenode机子了，此时allnode机子上就出现[root@basenode ~]# ,这说明登录上basenode了，再输入exit,就logout，connection to 192.168.133.100 closed.，就又回到allnode了。
这个过程我们是要输入密钥进行权限校验的，如果可以实现免密钥？原理是：
allnode要想免密钥登录到basenode上，allnode要先把自己的公钥发送给basenode, basenode只要把这个公钥存起来就可以了。就是只有一步操作即可，就是allnode把自己的公钥发送给basenode,basenode记住这个公钥即可。
所以allnode第一步就是生成自己的公钥和私钥，然后把公钥发送给basenode, 注意这里allnode发送给basenode公钥的这个信息在网络上传播是安全的，因为即使别人拿到公钥也没用。此时basenode拿到allnode的公钥后要保存，这里的保存路径是有固定的，就是只能保存到/root/.ssh/authorized_keys文件里即可，就可以相互免密钥了。

1、allnode生成密钥
代码：ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa
ssh-keygen表示key generate, 生成密钥
-t rsa表示使用rsa非对称加密算法。
-P ''表示生成密钥对儿的时候要输入的一个密码去生成，这里什么都没有填就表示使用默认方式生成公钥和私钥。
-f ~/.ssh/id_rsa  表示默认把生成的密钥放到家目录~下面的隐藏文件.ssh下面的id_rsa文件里面。
上面生成密钥的代码敲完回车就返回：
Generating public/private rsa key pair.  #表示已经生成了密钥对儿
Your identification has been saved in /root/.ssh/id_rsa.  #表示你的私钥存放在id_rsa文件里。
Your public key has been saved in /root/.ssh/id_rsa.pub.  #表示你的公钥存放在id_rsa.pub文件里
所以，我们发送给别人的密钥就是id_rsa.pub里面的公钥，私钥我自己留着。
randomart是生成的密钥的图形表示。

2、allnode把生成的密钥发送给basenode
代码：ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.133.100   #把公钥发出去
敲回车，再输入123456密钥，因为要免密钥登录对方，首先要知道对方的密钥说明两台机子是认识对方的才能免密钥。
回车，就返回：Number of key(s) added:1  , Now try logging into the machine, with:"ssh 'root@192.168.133.100'" , and check to make sure that only the key(s) you wanted were added.
这就表示这个公钥已经被对方存起来了。并且存在对方的/root/.ssh/authorized_keys文件里。

如果此时我们想查看公钥的信息用命令：cat ~/.ssh/id_rsa.pub ,回车就返回公钥的信息。
如果我们此时想查看basenode是否保存了这个公钥：
ssh 'root@192.168.133.100'  #登录basenode， 也可以用命令ssh 192.168.133.100 是一样的。
cat ~/.ssh/authorized_keys , 回车，就返回和cat ~/.ssh/id_rsa.pub一样的信息。

此时我们用allnode登录basenode就不需要密码了。
但是basenode是不能免密钥登录allnode的，因为basenode没有把自己的公钥发送给allnode,所以allnode不允许basenode免密钥登录。这就是相互免密钥做的事情。

说明：前面我们把allnode主机的域名dns改为node01了，就是先vi /etc/hosts，再添加一行：192.168.133.101 node01 
所以，当basenode和allnode已经相互免密钥了后，当basenode想登录allnode时，不仅可以ssh 'root@192.168.133.101' 登录，也可以ssh 192.168.133.101登录，还可以ssh node01  。但是，当我们用ssh node01时，会弹出对话框让我们输入yes or no, 来确定我们是否要继续链接，此时我们要输入yes才能免密链接。
所以，当我们要输入yes时就需要人工手动去确认，这样会干扰两台主机自动免密登录，如果我们想屏蔽这个需要人工输入yes的环节，我们就要修改一个文件即可，就是要进行 主机名与Host校验 的操作：
#主机名与Host校验
如果只是本次操作免去手动输入yes操作，以后还是需要手动操作的，用命令：
ssh -v -o GSSAPIAuthentication=no root@192.168.133.101  ， 就会返回一堆，但是还是能登录上allnode.
如果要永久免去输入yes操作，就要修改/etc/ssh/ssh_config文件的配置，修改步骤是：
vi /etc/ssh/ssh_config  #打开这个文件
shift+g 光标到文档的最后一行的开头, 再 o 光标到下一行， 输入下面这两行代码：
StrictHostKeyChecking no        #严格的主机名检查设置为no
UserKnownHostsFile /dev/null  #已知的主机信息写道/dev/null里面
输入完毕后:wq!保存并关闭。
此时在输入ssh node01, 就不检查主机名和host地址了。

#修改known_hosts确认信息
在basenode机子上用命令：
cd .ssh/   #进入.ssh目录下面
ll    #显示.ssh文件夹里面的文件， 我们发现有一个文件叫known_hosts
vi known_hosts   #显示known_hosts文件的内容，我们发现文件的内容都是我们以前连接过的主机的ip地址。如果我们把这个文件里面的东西全部删完，此时我们再连接allnode的时候就又要输入yes确认是否要继续连接。

说明：免密钥也包含对自己登录也免了自己的密钥。就是自己登录自己也要免密钥。也就是把公钥也给自己复制一份就可以了。

#免密钥数据校验过程
由于公钥和私钥是会过期的，因为allnode是通过命令ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa生成的，生成完了发送给basenode, basenode保存用于免密校验。但是如果allnode又ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa了，就是又生成一个新的公钥了，就是说密钥是会过期的。

所以我们要知道相互免密钥的流程：
allnode生成一对儿公钥和私钥：ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa  ，其中，私钥存在自己的/root/.ssh/id_rsa文件里面，公钥存在自己的 /root/.ssh/id_rsa.pub文件里面。
然后，allnode把公钥发给basenode ：ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.133.100 ，并输入basenode的密码才能发送成功。如果发送成功，对方basenode就把allnode的公钥存在自己的 /root/.ssh/authorized_keys文件里。
此时allnode给basenode发消息就可以免密了。

就是allnode给basenode发一个'请求连接'的公钥消息包，basenode先去它自己的authorized_keys里面看看有没有allnode的公钥，如果basenode的authorized_keys里面没有allnode的公钥，basenode是拒绝这个'请求连接'的公钥消息包的，只有allnode输入了basenode的密码，basenode才接受这个'请求连接'的消息包，而且把'请求连接'的公钥信息保存到自己的authorized_keys文件里面。
下一次allnode再给basenode发其他消息包，比如'访问basenode系统'的消息包，basenode会先去检查一下它的quthorized_keys文件里面有没有allnode的公钥信息，如果没有就拒绝接受这个消息包，除非allnode再输入basenode的密码；如果有公钥信息，但是这个公钥信息也有可能是过期的，所以basenode先把allnode的公钥取出来，用这个公钥加密一个随机生成的字符串，然后把这个加密后的字符串发给allnode；allnode拿到字符串后用它的私钥解密，并把解密后的字符串发给basenode; 此时如果allnode的私钥是正确的话，basenode收到的解密字符串应该和发给allnode的用allnode公钥加密前的字符串应该相同，所以basenode对比这两个字符串，如果相同，basenode就接受allnode发给它的消息包，allnode就可以访问basenode的系统了。如果不同，basenode就拒绝接受这个消息包，除非allnode输入basenode的密码，basenode才接受。
这就是验证公钥私钥的一个完整的流程。也是主机之间相互免密钥的原理。

#日期和时间模块
刚开始我们按照linux操作系统的时候需要配置时间，其实时间是没必要配置的，因为安装完毕后可以用命令修改。
#查看系统时间的命令：date  , 返回我们系统的时间，如果这个系统时间不对就要修改。
#修改系统时间：
date -s 11:11:11    #修改的是时间
date -s 2019-11-11  #就修改成2019年11月11日00：00：00
date -s '2019-11-11 11:11:11'  #就修改成2019年11月11日11：11：11
#自动同步时间
上面是修改一台机器的命令，如果我们有一个集群，这个集群里面有5台主机，我们需要这5台主机的时间要同步。
如果某台主机自己和自己的时间不同步，那别人给这台主机发的第一条消息的时间很可能在第二条消息的时间的后面，就出现混乱。如果某两台主机的时间彼此不同步，第三台主机先给第一台主机发消息比如说是一点10分，再给第二台主机发消息时间可能就显示的是1点8分，这样第三台主机的时间就混乱了，很多消息是会过期的，这中间有2分的时差，也许消息都过期了。所以，当所有的主机都在一个集群里面，我们可以通过xshell统一修改。

但是，当有不是所有的主机都在一个集群里面呢，比如我们的主机和阿里的主机进行支付时，我们的主机在我们的时间8：20发起了一个支付请求，阿里主机在阿里的时间上显示的是8：18收到一个支付请求，这样时间就出现不一致了。此时我们不可能去支付宝的服务器上修改它的时间的，那我们的时间如何保持同步呢？此时我们就需要一个策略保证各个主机之间的时间是同步的。这个策略就是，首先我们先假定公司的某一台服务器的时间是正确的，就是假定这台服务器的时间永远不会错，如果错大家都跟着错，大家也都不错了。那么这台服务器下面的子服务器就都同步公司的这台服务器。同理，各家公司都同步各家的假定的那台正确时间的服务器。
日期自动同步需要一个ntp的组件，首先要安装这个组件：yum install ntp -y
安装完毕后我们让这个软件去同步一个 同步时间的服务器 即可： ntpdate cn.ntp.org.cn

说明：ntp是网络时间协议（Network Time Protocol），它用来同步网络设备【如计算机、手机】的时间的协议。
我们百度‘cn.ntp.org.cn’就会搜到ntp.org.cn的网页，这个就是同步全世界时间的服务器，点击进去会看到我国各个地方都有同步时间的服务器，如果你是东北的，东北大学提供的节点IP是2001:da8:9000::81, 比如我的机子就同步的是182.92.12.11是北京的阿里云同步时间服务器。所以当我们输入命令ntpdate cn.ntp.org.cn就表示我们访问cn.ntp.org.cn网站服务器的时候，就会就近转化为对应的ip地址，我们就可以就近的ip地址上同步时间了。如果没有成功就再试。这样我们就和全世界遵循这个时间协议的服务器的时间都一样了。
这个命令ntpdate cn.ntp.org.cn我们不用时时刻刻去运行，我们只要每一天或每两天运行一次就可以。像我们的windows里的时间，就是我们电脑的右下角的时间，这个时间就是每2天自动同步一次。

#本地搭建NTP服务器
如果我们的服务器是内网服务器就是不能和外网连接，那就不能登录cn.ntp.org.cn了，那我们要同步时间，只要这些内网的服务器去和其中一台主机同步，这样所有的内网服务器就同步了。比如，我们让basenode开启同步时间服务：
service ntpd start  , 就返回: Redirecting to /bin/systemctl start ntpd.service  , 表示basenode开启了这个服务，就是basenode可以给我们局域网内部其他服务器提供 同步时间 的服务了。
然后在内网的其他服务器比如allnode上敲命令：ntpdate 192.168.133.100  ，就将allnode的时间和basenode同步了。

#ntp的配置文件也是可以去设置的。
命令：vi /etc/ntp.conf   就打开了ntp的配置文件
文件里面的：restrict 127.0.0.1 和 restrict ::1表示默认本地的自动同步
restrict 192.168.1.0 表示默认本ip段的同步。
brodcast 192.168.1.255 autokey  表示默认的广播服务同步。
这些都是授权谁谁可以访问我们，这些是可以自己配置的。

#用户-组-权限
#用户的操作
用户操作就是说你以什么身份登录这个系统。工作中我们一般是不同的用户去安装不同的软件，去管理不同的软件。比如我们安装一个mysql软件,我们是先创建一个mysql的用户和mysql的组，这样我们就可以用mysql的用户名去管理mysql的信息，这样不会对电脑整个系统造成大的隐患。如果一个应用软件用的是超级管理员登录管理的，那这个应用软件如果修改或者删除了一些操作系统的文件我们也不知道，所以我们要单独创建一些权限较低的用户去管理这些应用软件。

#新增用户： useradd libai   
然后再输入密码：passwd 123456  ,  就创建了一个新用户
用这个新用户登录系统：先exit退出系统-- 然后ssh 192.168.133.101登录---在弹出的对话框输入用户名libai, 输入密码123456，就登录上了。
说明：只有超级管理员才有权限生成新的用户名，而且创建的新用户都放在/home目录下面，就是在家目录下面。
cd /home  , ll  , 就看到家目录里面的用户名了。

#删除用户：userdel -r libai
说明：删除用户也是只能超级管理员才能删除，其他普通用户不能删除普通用户。

#修改用户信息
usermod -l libai1 libai     #家目录和组名称是不会被修改的。
usermod -L libai   #锁定用户名
usermod -U libai   #解锁用户名

#查看用户名和密码的配置文件：cat /etc/shadow
返回的是用户名和密码，我们可以看出root用户的密码和libai的密码不一样，但是我们设置的时候都是123456，但是密码不一样，因为这里的密码显示的是不可逆加密算法的加密后的密文，而且用了加密盐技术，就是比如把用户名和密码一起加密，所以即使密码相同加密后的密文也不同。

#查看用户名、编号、组编号、家目录、命令码、目录：cat /etc/passwd
说明：6.5linux系统0-499 普通用户是从500+开始  ， 7.6系统0-999 普通用户1000+

#切换用户：su libai,  就从root用户切换到libai用户了。
说明：管理员账户切换普通用户直接su 用户名  即可，普通用户切换到管理员用户su root后还需要输入密码。

#组
#创建组：groupadd lyy1   #就是创建lyy1组
#删除组：groupdel lyy1   #就是删除组lyy1
#修改组名：groupmod -n lyy1 wantong   #就是把组lyy1改为wantong
#查看用户对应的组：groups  #查看当前用户所对应的组 ，返回的是root, 因为每创建一个用户就会同时创建一个同名的组。所以当我们输入：groups libai  , 就返回libai: libai ,表示libai对应的组也是libai

#修改用户对应的组：
比如我libai这个用户调到lyy1这个组下：usermod -g lyy1 libai    #就把用户libai放到组lyy1下面了。
groups libai  , 就返回：libai : lyy1
说明：组又分主组和附属组
所以，如果我们还想把用户libai添加到libai这个附属组里面：usermod -G libai libai
此时，再敲groups libai , 就返回：libai : lyy1 libai  , 意思就是用户libai不仅在主组lyy1里面还在附属组libai里面。

#关于 用户组权限 的判定
当我们敲ll时，显示的当前文件目录下面的所有可显示文件，这些文件有-、d、l 三种开头的，-表示文件，d表示文件夹，l表示链接相当于快捷方式。再往后就是rwx rwx rwx 三个字符一组，有三组。其中，r是读的权限，w是写的权限，x是执行的权限。如果某个权限没有的话就用-代替，就表示没有这个权限。比如r-x表示有读和执行的权限，rw-表示读写的权限，r--表示只有读的权限，---表示什么权限都没有。三组是因为：第一组代表所属用户的权限，第二组代表所属组的权限，第三组代表其他人的权限，就是既不是这个组也不是这个用户的其他人的权限。
所以：rw- r-- rw- libai tang 这句代码的语法就是：用户libai能够进行读写但没有执行的权限，组tang有读的权限但没有写和执行的权限，但是其他用户有读写的权限但没有执行的权限。
再比如：drwxr-xr-x 3 root root 就表示：第一个d表示这是一个文件夹，3表示这个文件夹里面有3个文件，第一个root是用户名，第二个root是组名。rwxr-xr-x表示用户root对这个文件夹有读写执行的权限，组root对这个文件夹有读和执行的权限但没有写的权限，其他用户也是只有读和执行的权限没有写的权限。

我们在[root@allnode ~]# useradd dufu   #就表示我们在家home目录下面创建了一个普通用户dufu， 并且同时生成了一个组叫dufu
我们再[root@allnode ~]# passwd dufu  #给dufu这个用户名加上密码，比如123456
此时，我们退出系统exit，从dufu用户名登录系统：ssh 192.168.133.101, 输入用户名dufu, 输入密码123456， 就用dufu用户名登录到系统了。
[dufu@allnode ~]$ pwd  , 返回： /home/dufu
用dufu这个用户名创建一个文件denggao：[dufu@allnode ~]$ denggao
[dufu@allnode ~]$ ll , 就返回： -rw-rw-r-- 1 dufu dufu 0 Dec 29 23:35 denggao  ,表示用户dufu和组dufu对这个文件都是等读写不能执行，其他用户对这个文件是只能读不能写和执行。
用dufu这个用户名创建一个文件夹shi：[dufu@allnode ~]$ mkdir shi
[dufu@allnode ~]$ ll ，就返回：drwxrwxr-x 2 dufu dufu 6 Dec 29 23:39 shi
对文件夹来说，它的w表示的是可以更改文件夹的名称、删除文件夹、在文件夹里面创建子文件等操作都是对文件夹的写w

假如我的普通用户除了dufu还有libai，意思就是dufu和libai都在目录/home下面，都是/home下面的文件夹。此时我们是以dufu这个普通用户登录系统的，也就是[dufu@allnode ~]$ ,此时我们敲cd /home/libai 就会报错：permission denied， 就是说你是用户dufu， 你就不能进入libai的文件夹里。为什么呢？我们把目录切换到/home目录下再ll,返回：
drwx------ 3 dufu dufu 88 Dec 29 23:39 dufu
drwx------ 2 libai lyy1   83 Dec 29 23:30 libai
这说明这两个文件夹只有自己的用户可以读写执行，其他用户和组都无权读写执行。所以我们是dufu用户的时候连进入libai这个文件夹都进不去。意思就是两个不同的普通用户是不能互相进入的。
但是，超级管理员是可以访问普通管理员的：[root@allnode ~]# cd /home/libai  是可以进入的。
说明：在超级管理员root面前是没有权限一说的，它可以进入任何文件夹。就是root就根本没有权限可以限制它。

#修改某个普通用户的权限
修改普通用户权限的模型叫UGO模型，user group other, 用户组其他，
[root@allnode ~]# cd /  , 再ll, 我们可以看到/下面的所有非隐藏的文件夹。
我们看opt这个文件夹：drwxr-xr-x. 3 root root  43 Dec 3 22:45 opt  
从这里看opt这个文件，其他非root用户只有读和执行的权限。
[root@allnode ~]# cd /opt    
[dufu@allnode ~]$ cd /opt    
[libai@allnode ~]$ cd /opt    
说明这三个用户都可以进入opt.
此时，我们用root用户在opt里面创建一个文件：touch file01
ll ,就返回：-rw-r--r-- 1 root root 0 Dec 30 00:27 file01  , 表示这个文件只有root可以读写，其他人不能写只能读。
vi file01 ， 在file01里面写入内容，比如abcdefg.... , :wq回车保存。
cat file01就看到文件内容了。
当我们用dufu或者libai用户cat file01时也可以看到文件内容，但是当用这些用户vi file01时，也可以进入编辑文档的状态，但是当我们修改时就报readonly的警告。
那如何修改普通用户的权限呢？让dufu和libai也可以修改这个文件：
第一种方法：我们修改一下file01这个文件的权限，我们把它改为-rw-r--rwx 就可以了。
第二种方法：我们把这个文件所属的用户和所属的组都从root换成dufu或者libai，这样普通用户也可以修改这个文件了。
[root@allnode opt]# chown dufu file01
[root@allnode opt]# ll , 文件file01就变成了：-rw-r--r-- 1 dufu root 27 Dec 30 00:29 file01 ,此时dufu 就可以操作这个文件了。
[root@allnode opt]# chmod o+w file01
[root@allnode opt]# ll , 文件file01就变成了：-rw-r--rw- 1 root root 27 Dec 30 00:29 file01 ,此时dufu也就可以操作这个文件了。
小结：以后修改文件的权限可以从rwx和UGO两个方面进行修改了。
当用户的组被修改之后，需要重新登录才能获取新组的权限。
chmod ug+rw file01
chmod ugo+rw file01
文件夹递归处理。

#管道与重定向
管道就是：将前面命令的结果作为参数传递给后面的命令。就是一种数据传递的方式。
命令：head -8 /etc/profile | tail -1  #表示把文件/etc/profile的第8行作为输出进行输出。
这里的竖杠|表示把竖杠前面的命令的结果当前参数传递给后面，然后再执行竖杠后面的命令。
这个功能我们用的最多的就是用来查询的，比如：
ps -ef  #就打开系统进程
netstat -anp   #就查出来很多端口和进程的信息。
netstat -anp | grep 6914   #把竖杠前面的命令查询出来的结果当作参数，再进行查询有6914的信息，这个命令就查询出来很多6914的数据信息。
说明：grep是一个强大的文本搜索工具，比如命令：
cat profile | grep if  #cat profile表示显示profile文件的内容，grep if 表示把以if开头的行都拿出来。
所以这个代码就表示先打开profile文件，然后在profile文件里面查询所有以if开头的行。

重定向就是，改变数据输出的位置、方向。
重定向是shell编程里面的一些语法，但是要讲进程就必须先了解重定向。
默认情况是，比如我们ll /opt  就在屏幕上出现opt文件夹里面的文件了
或者我们敲ll /op就在屏幕上报no such file or directory,就是报错，
所以，默认的是不管是正确信息还是错误信息都输出到我们的显示器上了。而重定向是改变数据的输出显示位置，我们可以不让数据输出显示到显示器上，比如日志数据，我们可以让日志数据输出到一个文件夹里或者一个文件里。
重定向的方法：1>是标准输出就是正确输出，1可以省略不写； 2>是错误输出， 如果是错误输出就必须写2。

命令：ll /opt > test   #这条命令屏幕上就没有打印任何信息，因为把信息扔到test文件夹里面了
cat test  #就返回test文件里面的内容了，内容就是原来opt里面的文件和文件夹。而test文件是自动在root目录下创建的文件。我们也可以vi test  就是几行显示文件及文件夹的字符串。
此时，我们再：ll /etc > test   #把etc文件夹里面的内容发送到test文件里面，并且覆盖里面原来的内容。
此时再vi test 我们发现test里面原来的内容被覆盖了。
如果我们是ll /opt > test  再 ll /etc >>test 就是在test文件里面追加etc的内容了

如果是错误信息，比如ll /op 这条命令返回的信息，如果想追加到test里面，用ll /op >> test就会报错，就要用：
ll /op 2>> test  就追加了。如果用ll /op 2>test就覆盖了。

如果我们想追加到文件里的信息不管是正确的还是错误的都追加，用2>&1
比如：ll /opt/as >> test 2>&1  就把/opt/as这个我们也不知道是正确的信息还是错误的信息都追加到test里面了。

小结：一个>是覆盖，两个>>是追加。正确信息1可以省略，错误信息2必须写。不知道信息正确与否都想输出就在命令后面加2>&1 。只要你想把信息写到一个文件里面>test就自动在root目录下生成一个test文件并且写入输出信息，所以你可以任意生成文件，比如 ll /etc > test,  也可以 ll /etc > test01  也可以ll /etc > test02，你可以随便命名文件的名字。

重定向就是把输出到屏幕上的信息打印到其他地方，其他地方默认的就是root目录下面自己命名的文件。而打印信息到一个文件中，这些信息分为覆盖打印和追加打印(>/>>)，还分正确信息和错误信息(正确信息直接打印，错误信息要2>/2>>, 如果不知道是正确信息还是错误信息后面加2>&1).

#数据黑洞
数据黑洞就是一个空间，我们可以将数据丢到黑洞中，但一旦丢进去就想再找回来。
方法：就是把数据追加到 /dev/null 里面即可
比如：ll /etc >> /dev/null   什么都没有返回，就是/etc里面的数据我们写到了/dev/null里面了，但是我们无法查看/dev/null里面的内容。
也可以写：ll /opt/as >> /dev/null 2>&1  或者 ll /opt/as 2>> /dev/null  或者  ll /opt/as 2> /dev/null  都可以。
往黑洞里面写数据的作用是：我们就不用清理一些打印数据了，比如我们ping www.baidu.com时一些日志数据就一直打印到屏幕上，如果这些数据不用保留，我们就直接写到黑洞里就连删除也不用删除了。这样数据是一直在打印的但是我们不用浪费空间保存。再比如安装软件的时候有很多中间过程，而中间过程产生的数据我们不想要，如果我们写到黑洞里去打印过程就不提示了。
如果我们要保留打印数据就不能往黑洞里面写！

#Linux的系统进程
进程是大于线程的。一个进程中包含好多线程。进程可以理解为windows的任务管理器。任务管理器中有'应用'和'后台进程'两部分。
linux中查看进程的命令是：ps -ef
返回信息中，UID是用户ID； PID是进程ID； PPID是父进程ID,就是当前进程的父进程，PID这些子进程都是由父进程开启的。 TIME是时间；CMD是对应的命令，什么命令开启什么进程。 

比如，我在allnode端敲命令ping www.baidu.com >> baidu  , allnode就开始不断往baidu这个文件夹里面写东西了。此时我再开启一台allnode, 在这新开启的allnode上敲命令：ps -ef , 查看allnode的进程信息。我们可以看到ping www.baidu.com这条命令对应的进程是7810，就是当前的进程，这个进程是root执行的，而7810进程的父进程是7790， 而7790进程的命令是-bash, 是root执行的，父进程是7788；7788进程的命令是sshd: root@pts/0, 是root执行的，父进程是6773；6773进程的命令是/usr/sbin/sshd -D , 是root执行的，父进程是1；1进程的命令是/usr/lib/systemd/systemd --switched- root --system - #A, 是root执行的，父进程是0。
说明：sshd中带d的都表示开启的是服务器。
A:这其实就是我们的系统服务。系统服务的父进程是0，这个0父进程可以想象成我们的系统引导分区，就是当系统一启动的时候引导进程引导程序依次往下创建。

搜索进程中我们关心的数据：我们现在知道allnode有一个ping 百度的进程，我们想看看这条进程，就用查询：
ps -ef | grep baidu  , 返回：root 7810  7790  ping www.baidu.com  和 root 7849  7813  grep --color=auto baidu
先然搜索返回的结果中第二条不是我们要搜索的内容，它是我们当前grep这个条命令对应的进程信息，我们要搜索的是第一条进程。

命令：ps -aux  返回的结果有cpu的使用率、内存MEM的使用率、磁盘、网络等的使用率，就是可以看到当前进程对内存的使用情况。类似window任务管理器里面视窗界面展示的。
命令：ps -aux --sort -pcpu     #sort是排序的意思，就是按cpu使用率从大到小排序。
命令：top  #动态展示一下各个硬件的使用率情况。

小结：在linux中所有的进程都被实例化成一个个文件，我们都可以去找到这些文件。上面展示的都是目前电脑上各个应用的前台进程。而这些应用的前台进程查看如下：因为前台进程文件都放在/proc/里面，所以：
cd /proc  再ll  , 会返回一大堆名称为数字的文件夹。当我们程序一开启的时候这些数字名称的文件夹就被创建了，每个数字名称文件夹里面就包含了开启的进程所需要运行的上下文数据，就是包含了我们这个进程程序运行过程中所需要的一些变量、数据等。当这个进程结束的时候，这些数字文件夹就可能会被删除。

删除一个进程：kill -9 进程名
比如删除刚才运行ping www.baidu.com的进程，命令ps -ef 就查看出这个进程是7810， 再命令cd /proc 再ll ， 就发现了7810这个伪文件夹，我们现在删除这个伪文件夹：kill -9 7810  这样就把这条进程杀死了，就是结束了。此时我们再ps -ef 就发现这个进程没有了。再看proc里面的文件发现7810这个文件夹也没有了。
所以，虽然进程也有一个本地的文件，但这个文件是一个伪文件，这种文件是随着进程的创建而创建，随着进程的销毁而销毁。

上面都是前台进程，前台进程的意思就是当我们敲了命令,比如ping www.baidu.com这个命令，这个命令就一直在前台执行，那电脑一直在执行这条进程，我们其他的命令就不能执行了，所以我们要让这条前台进程变为后台进程，让这条命令在后台慢慢执行即可，不用前台执行，妨碍我运行其他命令。那如何做一个后台进程呢，就是让执行这条命令的是不让它一直往外打印消息即可：
命令是：ping www.baidu.com >> baidu &       #就是命令的后面加一个&符号，这样这条命令就返回[1] 7887 就表示这条命令在后台悄悄执行。
命令: jobs  #就返回电脑当前正在运行的后台进程，所以这里就返回的是：
[1]+ Running   ping www.baidu.com >> baidu &
allnode我们可能开启了2台或者更多，假如我们在其中一个allnode上敲ping百度命令，这台allnode就执行这条命令，但是有的命令我们是希望一直在后台执行的，万一我们把这个allnode关闭了，这个后台命令很可能就中断执行了，那我们不能让它中断，就是我们要防止后台进程被挂起：nohup ping www.baidu.com >>baidu 2>&1 &

如果我们敲命令是：nohup ping www.baidu.com >>baidu &  就返回提示：
nohup: ignoring input and redirecting stderr to stdout  , 意思就是提示你，你的命令是>>就是要输出标准输出(正确输出)的，但是nohup就会把错误输出也输出到正确输出里面了。

#Linux的软件安装

#环境变量
linux中的环境变量和windows里面的环境变量的作用是一样的，作用都是：当我们执行一个命令的时候，默认都是从当前路径开始查找，如果当前路径找不到对应的命令文件，就从环境变量$PATH中查找。$PATH的配置文件在/etc/profile
window路径与路径之间用分号;连接 。linux路径与路径之间用冒号: 连接  , 并且linux每次修改完成之后需要重新加载文件：source /etc/profile

比如我们现在执行ping命令，但是当我们ll时我们会发现root下面并没有Ping文件呀，那么这个ping命令是怎么就可以执行了呢？那就是因为系统从环境变量中查找到这个命令对应的文件了。
#查看环境变量文件
vi /etc/profile   #这个profile文件就是我们传说中的环境变量文件。
如果我们要修改环境变量，就是给这个文件添加东西，就在这个文件最后写。
在windows里面：我的电脑-属性-高级系统设置-高级-环境变量-分用户变量和系统变量
类别windows，linux中的/etc/profile文件就是系统变量文件。linux中的用户变量在/root家目录下面，用命令ll -a 查看，会发现/root目录下面有个.bash_profile文件，这个隐藏文件就是linux的用户变量文件。这个文件也是可以添加东西，只是添加后只对当前用户起作用。所以，一个变量是要设置到用户变量文件里还是设置到系统变量文件里，要这样考虑：如果这个变量被多个用户使用，这个变量要添加到系统变量文件里，如果这个变量只能这个用户自己使用，就添加到用户变量文件里。
#打印环境变量$PATH
echo $PATH   , 返回：/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
说明：如果当你发现突然ping、echo、cat等命令不能用了，很可能是你的环境变量被人更改了，或者弄坏了。如果你是windows系统，此时最直接的修复方式就是拷贝别人的环境变量。

#软件的安装方式
windows上安装软件方法一：去软件的官网下载软件的安装软件，然后按照提示下一步下一步一步步安装。
方法二：有些软件下载完毕不用安装，解压就可以用。比如比较工具beyond compare.zip 就是解压就可以用了。这种叫解压安装。
方法三：源码安装。比如，如果我们用java写了一个程序，这个程序要装到windows上面，那我们安装这个软件，就首先要把java软件进行编译，编译完后再安装执行。因为当我们写一个程序时，我们可能用java写也可能用c写，写完这个软件后，我们也不能确定安装者的电脑的各种配置，比如内核的数量、是32位还是64位、是win7还是xp,等等，这种情况下，我们索性打包一个软件的源码包，这样安装者想怎么安就怎么安。另一方面，我们有了一个软件的源码，那我们想怎么改就可以怎么改，这样就给我们提供了很大的灵活性，但是按照过程非常繁琐，因为一切都要你自己配置。
方法四：使用一个平台帮我们安装。比如电脑按照一个360软件管家，就可以一键安装。不用自己去官网下载软件安装。所以不管是360，腾讯、百度、阿里等有自己的软件库。

#RPM安装
Red-Hat Package Manager (RPM) （红帽软件包管理器）是一个强大的命令行驱动的软件包管理工具，用来安装、卸载、校验、查询和更新 Linux 系统上的软件包。
Windows上安装的软件的后缀名都是.exe
linux有两大分支，一个是redhat, 一个是debian, 其中，debian的可执行文件的后缀名都是deb，redhat的后缀名都是rpm。我们现在是centos，所以要安装rpm包
。。。。。。
。。。。。。

#安装jdk
软件安装完毕，也可以卸载：

#rpm安装JDK

#tar安装tomcat
......

.......................
#  Linux三剑客-cut  、sort、wc  / grep /sed /  awk
这些命令基本都是针对文本，对文本的处理，比如切分、排序、统计单词个数等。其中grep、sed、awk最秀，awk就可以写一本厚书。

#cut  :用指定的规则来切分文本
cp /etc/passwd ./    #把etc里面的passwd文件拷贝到 当前目录里面
ll                            #查看当前目录里面的文件，我们会发现就有一个passwd文件。
cat passwd             #查看这个文件的内容，这个文件里面有很多:冒号
cut -d ':' -f1,2,3 passwd | grep root    #我们用:切分一下passwd文件的内容,然后再搜索一下里面有root的文本。-f1,2,3表示切分后的数据排成3列
返回：root:x:0
cut -d ':' -f1,2,3 passwd   #就返回的是passwd文件中的每行以冒号切分后的前三列。

#sort   排序
sort passwd   #把passwd文件里面的内容，按每行的首字母从小到大进行行排序。字符串之间的排序是通过字母的字典序来排序的。

passwd文件里面的每行代表一个用户的信息，其中每行的第三列是这个用户名的编号，我们可以用这个编号给所有用户排序：sort -t ':'  -k3 passwd  #这种排序方式，即使按第三列排序，第三列都是数字，但是它把数字也当成字符串处理，对比字符串的大小进行排序了。
sort -t ':'  -n -k3 passwd  #加一个-n参数就表示按照数字大小排序。

倒排序：sort -t ':'  -k3 -r passwd   #就是从大到小排序。

#wc    统计单词world count
wc passwd  #统计passwd文件里面的单词数
返回： 21 29 914 passwd   #21代表行数line,  29代表单词数量word，是去重的单词量，914代表字符char的数量。
wc -l passwd     #返回21, 就是有21行
wc -w passwd    #返回29，这里的单词数量的统计是按空格统计的，如果单词和单词之间用的是:连接就算一个单词。
wc -c passwd     #返回914，这里统计的字符数量，比如hello就是5个字符，：号也是一个字符， /也算一个字符。

#grep  搜索
ps -ef | grep root   #查进程里面的带root的信息
ps -ef | grep thread  #查进程里面的带thread的信息
grep root passwd    #在passwd文档里面搜索带root的行
grep root passwd /etc/shadow  #我要在passwd文件和shadow文件，两个文件里面都查找root字符串。
grep -n root passwd     #在passwd中找到带root字符的行后，打印这行并显示这行的行号。
grep -nvi root passwd  --color=auto  #显示不匹配的，并且忽略大小写
grep -E"[1-9]+" passwd --color=auto  #使用正则表达式搜索
小结：grep是找文件的内容，find是找文件。

#sed 
sed命令是操作、过滤、转换文本内容的强大工具，有增删改查、过滤、取行等功能。
这里的sed版本是GNU开源版本，实验环境是CentOS6.8系统，内核版本是2.6.32-642.el6.x86_64
sed软件从文件或者管道中读取一行处理一行输出一行，再读取处理输出。。。。也就是sed读数据的时候不是先把整个文件都先加载到内存中，这样对内存的压力就比较小。
sed '2a nihao hello' passwd  #在passwd文件里面的第2行后面追加一行，追加的内容是nihao hello
但是我们此时cat passwd时，并没有nihao hello这一行。也就是上面的命令仅仅是给我们显示了一下，其实并没有真正的追加到文件里面。
sed -i '2a nihao ya' passwd  #此时再cat passwd就发现第3行是nihao ya ,就是真正追加上了。
sed -i '2,5a ni hao liming' passwd  #在第2行到第5行中的每一行的后面都再加一行，加的行写入ni hao liming
sed -i '2,+2a lyy' passwd    #在第2行后面加一行写lyy, 然后再往后2行，每行都后面加一行写lyy
sed -i '10~3a ---------' passwd  #从第10行开始下面一行写-----，然后每个3行下面写一行---， 所以~就是步长的意思

#awk
awk是一门语言，核心目标也是操作文本。
比如，我们敲命令ifconfig就把我们电脑的ip给显示出来了，但是是显示的一大堆，我们如果只把ip地址取出来？此时我们就百度‘centos7  awk获取本机ip’去搜索命令，然后试就可以了，因为太多不可能全部去记忆的。
也可以搜索'常见awk语法操作'去查找你想实现的命令。

--------------------------------------------------------------------------------------------------------------
###Shell 编程
shell是Linux的进阶部分，前面是linux的基本操作。shell编程的主要作用就是写脚本。shell脚本也有它自己的一套语法规则和编程规范。如果你主要从事服务器编程，那shell编程就是基本的技能。shell编程很简单但功能比较强大。
#kernel  
linux内核主要是为了和硬件打交道。linux这个单词指的就是这个操作系统的内核。
#shell
壳，命令解释器command interpreter，是用户和linux之间的桥梁。shell既是一种命令语言又是一种程序设计语言。
shell是一种应用程序，这个应用程序提供了一个界面，用户通过这个界面访问操作系统内核的服务。
比如我们要看视频、听歌曲，最终是要让声卡、显卡等硬件去接受我们的声音信号或者视频信号为我们工作，那要操作这些硬件就要操作内核，那程序员如何操作内核？用指令操作内核。如何用指令操作？在内核上搞一个壳，通过壳敲入指令。也就是我们通过壳去输入一些命令，壳把命令转换为指令，指令去调用内核，内核操控硬件。
比如，我们ll /etc, 而etc里面的文件都是存储在硬盘上，我们现在通过显示器上的一个黑框框输入一条命令ll /etc，这条命令是让硬盘上的东西查询出来，并且显示到显示器上。这里的硬盘、显示器都是硬件，计算机执行这条命令的时候就要使用主板、使用cpu。所以就执行这个简单的命令，计算机上很多硬件都要调动起来。也就是我们就是通过这个黑框框（壳）操作计算机的各个硬件的。
shell是操作内核的壳，所以壳可以有很多，只要能调用内核的壳我们都可以去使用。目前壳shell有两大主流：sh 和 csh。
sh有：Bourne shell(sh) 是Solaris , hpux默认的shell ； Bourne again shell(bash) 是linux系统默认的shell
csh有：C shell(csh)  和 tc shell(tcsh)
所以linux默认的壳是bash,所以说的shell编程基本说的都是bash编程。

cd /opt/apache-tomcat-8.5.47/bin
ll #就发现有一个startup.sh文件，这个文件就是一个脚本，我们通过这个脚本调用壳(就是通过脚本的命令去访问壳)-通过壳调用内核-通过内核去执行我们的代码。

说明：windows也有壳和内核，windows的壳就是cmd命令行的小黑窗口。比如我们在小黑窗口输入命令dir ,就可以查看我们的目录里都有什么。所以不同的操作系统，它对应的壳都是不一样的，不一样的壳对应的命令也是不一样的。windows系统中脚本文件是.bat为后缀的文件。
linux系统中的脚本文件是.sh为后缀的文件。

小结：壳就是shell, 壳是命令解释器，也就是一个黑窗口，通过这个黑窗口我们输入命令，这个黑窗口就把我们的命令解释为计算机指令，计算机指令进入操作系统的内核，内核执行这个指令，调用计算机硬件工作。
所以，壳有很多，bash只是其中一种壳的名字。bash同时也是一个文件，这个文件一般放在bin目录下面。bash同时也是一个应用程序，这个程序可以为我们提供提供那个小黑窗口，我们就是通过那个黑窗口用命令访问内核，内核操作硬件。

#如何写脚本文件
cd                  #回到root目录
rm -rf ~/*       #这个目录里面的东西有点多，全部清除。就是家目录下面的所以文件都清掉。
ll  , 返回0
vi hello.sh        #创建一个名为hello.sh的文件，并且打开这个文件。

写文件内容：
#!/bin/bash         #这是文件内容的第一行，第一行要先写声明，A
echo "hello world!"
A:告诉系统其后路径所指的程序是解释此脚本文件的shell程序  ,这行也可以写成#! /bin/sh  ,因为sh和bash是相互兼容的。这一行的内容指定了shell脚本解释器的路径，而且这个指定路径只能放在文件的第一行，如果第一行写错或者不写时，系统会默认一个解释器进行解释。
小知识点：#一般表示要注释掉整行的意思，！表示这行加粗了，而且只有#！在第一行的时候才能加粗。
写完脚本文件就保存：esc切入底行模式，输入:wq回车
ll  返回：-rw-r--r-- 1 root root 30 Jan 6 10:49  hello.sh #说明这个文件就是一个普通文件，而且是一个不可执行文件

执行脚本文件：有三种方式
1、输入脚本文件的绝对路径或者相对路径即可。说明：但前提是这个脚本文件是可执行文件。
./hello.sh  会返回permission denied.因为这个文件现在只是一个普通文件，没有可执行权限。./表示当前目录。
chmod u+x hello.sh   #更改hello.sh文件的权限，增加可执行的权限。
ll  此时我们会发现hello.sh这个文件已经变成高显状态了：-rwxr--r-- 后面文件名hello.sh是高亮的。
./hello.sh  就返回这个文件的内容：打印一个helloworld到屏幕上了。
/root/hello.sh  #也可以运行这个脚本文件。
而直接敲hello.sh会返回command not found.

2、用命令执行： sh 脚本文件  。此时如果脚本文件没有x权限时，root和文件所有者通过该方式可以正常执行。
sh ./hello.sh  #正常执行
sh /root/hello.sh  #这个命令和上面的命令是一样的。
sh hello.sh #也可以正常执行这个文件
chmod u-x hello.sh  #把可执行权限改掉。ll后这个文件就变成了-rw-r--r-- 
说明：即使这个文件改回去为不可执行文件，但是上面sh的三种命令都可执行这个文件。

3、在脚本文件的路径前加. 或者 source
source hello.sh
. hello.sh   #这个点后面一定要加一个空格，否则报command not found.
source ./hello.sh
source /root/hello.sh
都可以执行这个文件，也不用考虑这个文件的权限。

小结：执行一个文件时，只有  ./文件名  这种方式下才需要把这个文件的可执行权限打开，其他方式执行文件都是不需要这个文件的权限的。
但是，方法1和方法2的命令是会新开一个bash,而不同bash中的变量是无法共享的。方法3是在同一个shell里面执行的。

vi hello.sh  #打开这个文件
在这个文件里面再添加一行代码：ping www.baidu.com >> baidu
保存文件：esc--:wq回车
这样我们一执行hello.sh这个文件，就会执行Ping百度这行代码，就会自动生成一个文件，文件名叫baidu,并且把日志往这个文件里面写。这就是一个脚本文件。就是这样写一个脚本文件的。
chmod u+x hello.sh     #修改文件权限
./hello.sh        #一敲回车运行这条命令，allnode就卡住了，因为它一直在执行ping命令。
此时，我们再打开一个新的allnode，暂时叫它allnode2吧，在allnode2里面敲ps -ef, 返回allnode现在的进程信息，从进程信息我们可以看到allnode正在运行的当前进程是
7781，这个进程对应的指令是ping www.baidu.com，父进程是7780                         #bash执行脚本里面的ping命令行
7780进程是在执行/bin/bash ./hello.sh   #A   ，父进程是7475                                      #bash执行hello.sh脚本
7475进程是在执行 -bash命令，父进程是7473     #B                                                     #allnode2开启一个bash
7473进程是在执行sshd: root@pts/1  ,父进程是6781                                                    #allnode2超级用户登录
6781是在执行/usr/sbin/sshd -D, 父进程是1                                                                 #allnode2链接到xshell
1是在执行/usr/lib/systemd/systemd --switched- root --system --dese  ,父进程是0       #从引导分区到登录allnode2
A：这条指令就是我们allnode上执行脚本文件里面的语句。
B：root用户一登陆就会执行-bash命令，就是root开启了一个新的bash进程。
此时我们把allnode的./hello.sh当前执行命令ctrl c中断掉，allnode2上ps -ef，就会发现很多进程不见了。
此时我们再在allnode上敲chmod u-x hello.sh 把文件的权限改回来，然后再敲：sh hello.sh  ，allnode就又卡住了
此时我们在allnode2上再ps -ef , 返回：
7815  是在执行ping www.baidu.com  父进程是7814
7814  是在执行sh hello.sh    父进程是7475
7475  是在执行-bash   父进程是7473
7473  是在执行sshd: root@pts/1  ,父进程是6781    
6781是在执行/usr/sbin/sshd -D, 父进程是1        
1是在执行/usr/lib/systemd/systemd --switched- root --system --dese  ,父进程是0

如果我们在allnode上敲：source hello.sh  , allnode就卡住，在执行ping命令。我们在allnode2上ps -ef, 我们会发现执行ping www.baidu.com这条命令的进程的父进程不是source hello.sh这条命令的进程！！！而是-bash命令的进程，-bash命令的父进程是sshd: root@pts/1，sshd: root@pts/1的父进程是/usr/sbin/sshd -D 。。。
这就说明我们用source hello.sh命令执行hello.sh脚本文件的时候，这个脚本文件里面的代码的执行不会重新再开启新进程，而是在同一个bash中执行的。

小结：如果我们用命令sh hello.sh执行脚本文件的时候，我们输完sh hello.sh这个命令敲回车的时候，操作系统就会给我们建立一个新进程来执行sh hello.sh。但是在执行sh hello.sh命令的时候，要执行hello.sh里面的某条语句的时候，比如执行ping百度语句的时候，执行sh hell.sh的进程就会新开启一个新进程，就是新bash进程，然后这个新bash进程再去执行ping命令。
如果我们用命令source hello.sh执行脚本文件，当我们输入source hello.sh敲回车的时候，就会生成一个新进程来处理这条命令。但在执行这条命令的时候遇到ping命令时，ping命令的执行还是执行source hello.sh的进程在执行它，没有新开启新bash。

说明：一个进程在执行过程中，它是否还开启新bash去执行子程序的区别在于：如果不开启，当前进程中的变量可以让子程序使用。如果开启新bash，那当前进程中的变量无法和新bash中的子程序共享。下面用这个例子展示：
name=libai  #定义一个变量名name , 把libai赋给这个变量
echo $name  #就打印出变量name的值libai
vi hello.sh  #打开hello.sh文件, 把ping www.baidu.com删掉，添加一行echo $name, 保存关闭。
sh hello.sh  #只返回了helloworld, 没有返回libai . 就是只打印出了helloworld, 而打印变量name就没打印出来。
source hello.sh #返回helloworld和libai .  
小结：这说明在当前我们的进程中，我们先是定义了一个变量name，然后在这个进程中我们再执行source hello.sh，然后依然在这个进程中执行source hello.sh命令的子命令echo $name, 所以echo $name中的变量name就共享了。
如果我们在当前进程中执行sh hello.sh命令，意思就是我们这个脚本文件需要在干净的环境里面运行，所以要再开启一个新bash来执行这个脚本文件，保证这个脚本文件在执行过程中的环境是干净稳定可靠可信赖的，因为脚本里可能有自己的变量，如果你还用原来的bash，原来的bash里面很可能有其他变量，这样执行脚本文件时，就和脚本文件里面的变量可能产生更改或者覆盖，这样脚本文件的运行环境就不干净了。所以要新开启一个bash去运行脚本文件，也就是新开启一个新进程而非原来的子进程去执行脚本文件，而这个脚本环境也随新进程的结束而销毁，这样可以保证整体系统的稳定性。
export name=baijuyi   #export一个变量name, 这个变量的值是baijuyi
echo $name   #返回的是baijuyi   , 因为我们export了一个变量，就是在当前进程中导入了一个变量name. 即使以前已经有这个变量name=libai, 现在也用baijuyi这个值把原来的libai值给覆盖了。
source hello.sh  #返回helloworld和libai . 
sh hello.sh   #返回helloworld和libai . 即使是新开启一个bash执行这个脚本文件，但是我们export了变量，export这个关键字就表示这个变量可以传递给新bash使用。所以我们以后配置profile的时候，所有的变量前必须加export.

小结：内核是为了调动硬件，壳是为了调动内核。要调用内核，就要写一个脚本去调用(A)，那运行脚本有三种方式(B)，
A:写脚本就是：第一行先写一个声明#!/bin/bash  ，后面行就是我们的命令，比如ping, echo等。
B:三种方式是./  、sh  、source  ,前两种会开启一个新的bash, 最后一种不会开新bash. 所以我们要用关键字export.

小结：前面我们安装了很多软件mysql, jdk, tomcat，学了很多命令grep、sed、awk、关闭防火墙等，如果我们每次新建一个虚拟机都要安装这么多东西，设置这么多命令，就非常耗时耗力，所以我们就可以写一个脚本文件，执行这个脚本文件就自动的帮我们安装、更改各种设置等。所以我们要学shell编程，学会写脚本文件，学会写一个电脑初始化脚本文件，让我们的电脑自动初始化。

#编程语言的学习流程
当你学会一门语言的时候，其他语言就简单了。
学一门语言，第一是学 ： 变量A--运算符B--逻辑语句C--方法函数D--应用E--框架F--中间件\组件G
A:  标识符/数据类型  （变量的作用域-成员变量/局部变量/全局变量/静态变量动态变量）
B:  让多个变量产生关系--数学运算符、逻辑运算符、位运算符、关系运算符
C:  顺序、分支、循环
D: 方法mechod、函数function--将实现某一功能的代码封装到一起，这样可以实现代码的复用。
E: 读硬盘上的文件、生成个数组用、网络上传递个数组、数组启动个多线程、、、等等
F: python的框架就是Django, Django是一个开放源代码的Web应用框架，由Python写成.许多成功的网站和APP都基于Django.而Django内部就是对 Socket 连接的强大封装.
G: 中间件又叫组件，是用了解决框架不能解决的问题。比如缓存、负载均衡等问题。

#shell基础入门
#变量
变量声明的时候不用加$符，当变量被调用时要加$
变量命名的时候要见名知意。变量命名只能使用英文字母、数字、下划线，首个字母不能是数字，中间不能有空格，不能使用标点符号，不能使用bash里面的关键字。可用help命令查看关键字。

变量的类型：
局部变量：在脚本或者命令中的变量。仅在当前shell实例中有效，其他shell启动的程序不能访问局部变量。
环境变量：外部变量基本就是环境变量，就是所有程序都能访问的变量，包括shell启动程序。很多程序是需要环境变量来保证其正常运行的。
shell变量：由shell程序设置的特殊变量。shell变量里面有一部分是环境变量，一部分是局部变量。

a=10
b=20
echo $a+$b  , 返回： 10+20   #这说明shell语言是弱变量语言类型，基本上所有的变量都默认成字符串处理了,就是都当成文本去处理了。

url="http://www.google.com"
readonly url
url=abc , 返回：-bash: url: readonly variable
unset url  #删除变量， 返回：-bash :unset: url: cannot unset: readonly variable

#shell的字符串
字符串可用单引号也可用双引号，也可以不用引号！
单引号里面如果出现变量，变量是无效的。就是不把变量转义成变量的值了。
双引号里面如果出现变量，变量是有效的。就是可以解析变量。
name1=lyy  ,        echo$name1   , 返回：lyy
name2='lyy2'       echo$mane2   , 返回：lyy2
name3="lyy3"      echo$mane3   , 返回：lyy3
字符串拼接：
name5=$name1'123'    echo$mane5   , 返回：lyy123
字符串的长度：
email='12345@qq.com'
echo ${#email}  ， 返回12

小结：字符串之间不加空格的时候是不用引号就可以直接赋值的。所以当拼接字符串的时候，如果拼接的时候也不加空格的时候就也不用引号直接拼接。比如：a=liming  , b=xiaohua  , c=$a$b  , echo $c, 返回limingxiaohua
当字符串中间有空格的时候就不能直接赋值和拼接，要在字符串外面加单引号或者双引号。
当加单引号的时候，就默认单引号里面的所有字符统统都是字符，按照字符输出。所以单引号里面的字符串里面出现变量或者感叹号等特殊字符时都按字符输出，所以单引号里面的变量是不会解析的，感叹号也不会转义的。
当加双引号的时候，就认为双引号里面的字符不都是字符串也可能有变量有特殊字符，那如果是变量就可以把变量解析出来，如果是特殊字符就把特殊字符转义。

切字符：
a=abcdefghijk    
echo ${a:2:5}   #表示从索引为2的开始往后截取5个字符，返回：cdefg
小结：shell里面的索引也是从0开始

#shell数组
bash支持一维数组，不支持多维数组，并且没有限定数组的大小。
ball=("足球" "篮球" "乒乓球")
echo ${ball[@]}    #查看数组里面的所有元素
echo ${ball[1]}   ,返回篮球  #查看数组中的某个元素。
echo ${#ball[1]} ,返回2  ， #查看某个元素的长度
echo ${#ball[@]} ,返回3  ， #查看数组的长度

#shell 的注释
注释掉的内容就会被解释器忽略
注释分单行注释和多行注释
单行注释用#即可。一行的开头用#号。
多行注释用   :<<EOF   EOF
        :<<!      !

#shell 运算符
算术运算符、关系运算符、布尔运算符、逻辑运算符、字符串运算符、文件测试运算符。。。运算符就是让变量与变量之间产生关系，得到我们想要的功能。
#算术运算符
a=10
b=20
c=`expr $a + $b`    ,返回30    #注意一定要写空格，如果没有空格就返回10+20
d=`expr $a - $b`    ,返回-10   
e=`expr $a \* $b`    ,返回200   
f=`expr $a / $b`      ,返回0     #这里只取整数了。

a=100
b=30
f=`expr $a / $b`        ,返回3     #这里只取整数了。
g=`expr $a % $b`      ,返回10     #取余数

#关系运算符
-eq   #相等
-ne  #不相等not equal
-gt   #大于greater than
-lt    #小于 little than
-ge  #大于等于>=
-le   #小于等于<=
关系运算只支持数字，不支持字符串

#布尔运算符
-a       # and 与运算, 两个表达式都为true才返回true
-o       #or 或运算，有一个表达式为true则返回true
!          #感叹号，非运算，表达式为true返回false,表达式为false返回true.
&&     #逻辑的and   , 这个符号表示：前面表达式是错的，后面的表达式就不执行了。
ll         #逻辑的or      ，           表示：前面表达式是对的，后面的表达式就不执行了。

#字符串运算符
=   #判断两个字符串是否相等
!=  #判断两个字符串是否不等
-z   #字符串长度为0
-n  #字符串长度不为0
a    #字符串是否为空

#文件测试运算符
-r   #是否可读
-w  #是否可写
-x   #是否可执行
-f   #判断是否是一个文件
-d   #判断是否是一个目录
-s   #判断文件是否为空
-e   #判断文件是否存在

#打印数据echo
echo "hello world"              ,返回hello world
echo "\"hello world\""        ,返回"hello world"    #\是转义符
echo -e "ok! \n"                 ,返回ok!            #\n是显示换行符
echo -e "ok! \c"                 ,返回ok!            #\c是显示不换行，此时的输入是在ok!后面紧接着显示[root@allnode~]#
echo 'hello world !!!' > myfile     #把hello world !!!打印到myfile文件里面。就是结果重定向到myfile里面去。
打开myfile文件，第一行就写着hello world !!!
echo `date`        #返回日期
echo pwd  #返回pwd
echo `pwd`  #返回/root   , 说明echo后面的语句是可以跟可执行语句的。所以当后面是可执行语句时要加``

#test命令
test命令主要是检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。

#shell 流程控制
if， case,  for , while,  break, continue