用while read line和/etc/passwd，计算用户id总和。
#!/bin/bash
sum=0
while read line ;do
if [[ "$line" =~ /sbin/nologin$ ]] ;then
uid=$(echo $line | cut -d: -f3)
sum=$(($sum+$uid))
fi
done < /etc/passwd
echo "用户id的总和为：$sum"
总结索引数组和关联数组，字符串处理，高级变量使用及示例。
数值索引：
数值索引：索引的编号从0开始
声明数组：declare -a NAME
删除数组：unset NAME
交互式数组赋值：read -a NAME
# 列出所有数组
[root@localhost ~]# declare -a
declare -a BASH_ARGC=([0]="0")
declare -a BASH_ARGV=()
declare -a BASH_COMPLETION_VERSINFO=([0]="2" [1]="11")
declare -a BASH_LINENO=()
declare -a BASH_REMATCH=()
declare -a BASH_SOURCE=()
declare -ar BASH_VERSINFO=([0]="5" [1]="1" [2]="8" [3]="1" [4]="release" [5]="x86_64-redhat-linux-gnu")
declare -a DIRSTACK=()
declare -a FUNCNAME
declare -a GROUPS=()
declare -a PIPESTATUS=([0]="0")
declare -a title=([0]="ceo" [1]="coo" [2]="cto")
# 只看title数组0号元素的值
[root@localhost ~]# echo ${title[0]}
ceo
# 显示students的所有元素
[root@localhost ~]# students=(zhang han luo wang hu)
[root@localhost ~]# echo ${students[*]}
zhang han luo wang hu
[root@localhost ~]# echo ${students[@]}
zhang han luo wang hu
# 数组赋值
[root@localhost ~]# title[0]=ceo
# 一次全部赋值
[root@localhost ~]# students=(zhang han luo wang hu)
[root@localhost ~]# echo ${students[0]}
zhang
[root@localhost ~]# echo ${students[1]}
han
[root@localhost ~]# echo ${students[2]}
luo
[root@localhost ~]# echo ${students[3]}
wang
[root@localhost ~]# echo ${students[4]}
hu
# 生成五个元素
[root@localhost ~]# number=({6..10})
[root@localhost ~]# echo ${number[*]}
6 7 8 9 10
# 交互式赋值
[root@localhost ~]# read -a car
benz audi bmw
[root@localhost ~]# echo ${car[*]}
benz audi bmw
关联索引：索引可支持自定义的格式，不仅仅是数字，bash4.0之后支持
# 声明数组：declare -A NAME
[root@localhost ~]# declare -A m48
[root@localhost ~]# m48[birth]="2022.2.8"
[root@localhost ~]# m48[num]=60
[root@localhost ~]# m48[classroom]=room3
[root@localhost ~]# m48[monitor]=zhang
[root@localhost ~]# echo ${m48[*]}
60 2022.2.8 room3 zhang
[root@localhost ~]# echo ${m48[num]}
60
[root@localhost ~]# echo ${m48[monitor]}]}
zhang]}
[root@localhost ~]# echo ${m48[monitor]}
zhang
[root@localhost ~]# echo ${m48[birth]}
2022.2.8
# 跳过三个数取四个数
[root@localhost ~]# num=({1..10})
[root@localhost ~]# echo ${num[*]}
1 2 3 4 5 6 7 8 9 10
[root@localhost ~]# echo ${num[*]:3:4}
4 5 6 7
# 查看元素的个数
[root@localhost ~]# echo ${#num[*]}
10
# 新添加一个元素
[root@localhost ~]# num[${#num[*]}]=11
[root@localhost ~]# echo ${num[*]}
1 2 3 4 5 6 7 8 9 10 11
字符串处理:
# 基于模式取字符串
# 从左到右找到'/'把斜杠和前面的内容删除
[root@localhost data]# url=http://www.baidu.com/index.html
[root@localhost data]# echo ${url#*/}
/www.baidu.com/index.html
# 删除所有斜杠之前的呢容
[root@localhost data]# echo ${url##*/}
index.html
# 从右到左找到'/'把斜杠和后面的内容删除
[root@localhost data]# url=http://www.baidu.com/index.html
[root@localhost data]# echo ${url%/*}
http://www.baidu.com
# 查找替换
[root@localhost data]# echo $url
http://www.baidu.com/index.html
[root@localhost data]# echo ${url/baidu/taobao}
http://www.taobao.com/index.html
[root@localhost data]# echo ${url/w/2}
http://2ww.baidu.com/index.html
[root@localhost data]# echo ${url//w/2}
http://222.baidu.com/index.html
# 查找删除
[root@localhost data]# echo $url
http://www.baidu.com/index.html
[root@localhost data]# echo ${url/w}
http://ww.baidu.com/index.html
[root@localhost data]# echo ${url//w}
http://.baidu.com/index.html
# 大小写转换
[root@localhost data]# echo $url
http://www.baidu.com/index.html
[root@localhost data]# echo ${url^}
Http://www.baidu.com/index.html
[root@localhost data]# echo ${url^^}
HTTP://WWW.BAIDU.COM/INDEX.HTML
# 转换成小写
${url,,}
高级变量使用:
变量替换和测试
变量替换：
①、${变量#匹配规则} #从头开始匹配,最短删除；
②、${变量##匹配规则} #从头开始匹配,最长删除；
③、${变量%匹配规则} #从尾开始匹配,最短删除；
④、${变量%%匹配规则} #从尾开始匹配,最长删除；
⑤、${变量/旧字符串/新字符串} #替换变量内的旧字符串为新字符串,只替换第一个旧字符串
⑥、${变量//旧字符串/新字符串} #替换变量内的旧字符串为新字符串,全部替换；
字符串处理
计算字符串长度：
${#string}
expr length "$string" //字符串中有空格则必须加引号
获取子字符****串中的索引位置：(获取的是字符的位置不是字符串的位置)
expr index $string $substring //获取满足$substring条件的字符串在$string中的索引位置
计算子串长度：
expr match $string substr //从头部开始匹配
抽取子串：
${string:position} 从 string中的position开始
${string:position:length} 从position开始，匹配长度为length
${string: -position} 从右边开始匹配
${string:(position)} 从左边开始匹配 ，索引从0开始
expr substr $string $position $length 从position开始,匹配长度为length,索引从1开始
命令替换
所谓命令替换就是将某一段需要命令执行的结果作为另一个shell命令的一部分。
语法格式：
command （反引号）
$(command)
有类型变量
通过declare声明变量类型
var1="hello world"
declear -r $var1 //声明var1为只读变量
declare -i - //声明为整形
declare -a - //声明为数组
（数组定义： arr=("mike" "joe" "juny")）
declare -f //显示定义的函数和内容
declare -f //显示定义的函数，不会显示内容
declare -x - //声明变量为环境变
(取消声明变量：把减号'-'换成加号'+')
数学运算：expr
(运算时，特殊符号要转义：| < > * & <= >=)
expr $num1 opearator $num1 //只能进行整数运算
$(($num1 opearator $num1)) //'*'不需要转义，在比较判断时可能出错，只能进行整数运算
求10个随机数的最大值与最小值。
[root@Rocky8]# cat shuzu.sh
#!/bin/bash
declare -i min max
declare -a nums
for ((i=0;i<10;i++));do
nums[$i]=$RANDOM
[ $i -eq 0 ] && min=${nums[0]} && max=${nums[0]}&& continue
[ ${nums[$i]} -gt $max ] && max=${nums[$i]} && continue
[ ${nums[$i]} -lt $min ] && min=${nums[$i]}
done
echo "All numbers are ${nums[*]}"
echo Max is $max
echo Min is $min
[root@Rocky8]# sh shuzu.sh
All numbers are 3328 31577 17306 18928 27517 23781 31799 13365 15350 20559
Max is 31799
Min is 3328
使用递归调用，完成阶乘算法实现。
#!/bin/bash
#Function:求阶乘
Func(){
x=$1
if [[ ${x} -eq 1 ]];then
echo "1"
else
echo "$[$x * $(Func $[$x-1])]"
fi
}
result=$(Func $1)
echo "$1的阶乘是:${result}"
[root@centos8 ~]# bash jiecehng.sh 6
6的阶乘是:720
解析进程和线程的区别？
进程（Process）是操作系统中的基本概念，它是系统进行资源分配和调度的基本单位，是正在运行程序的实例。进程拥有自己的地址空间、内存、文件描述符、状态等信息，进程之间相互独立，互不干扰。 线程（Thread）是进程中的一个执行流程，它共享进程的资源，包括内存、文件描述符、状态等。线程拥有自己的栈和局部变量，但是它们共享全局变量和静态变量等资源，线程之间的切换需要切换上下文。一个进程中可以包含多个线程，这些线程都共享该进程的资源。 下面是进程和线程的主要区别：
- 资源占用：进程独立占有一定的系统资源，而线程则共享自己所在进程的资源。
- 栈和局部变量：线程拥有自己的栈和局部变量，但是多个线程之间共享全局变量和静态变量。而进程拥有自己的独立空间，不会共享栈和局部变量。
- 调度：进程调度的开销相对较大，因为每个进程都是独立的。而线程的调度相对较轻，在多核 CPU 下线程可以同时运行。
- 独立性：进程具有相对独立性，进程之间可以互相通信。而线程依赖于所属的进程，多个线程之间的切换需要切换上下文，并且线程之间的通信需要通过进程提供的机制来实现。
解析进程的结构。
一个进程是由操作系统管理的程序运行实例。一个进程包括三部分内容：进程控制块、程序段、数据段。
- 进程控制块（PCB，Process Control Block）：也被称为进程描述信息，它是系统分配给每个进程的数据结构，用于统一管理系统中所有的进程。它包含了进程的相关信息，如进程状态、PC、CPU寄存器的值、进程ID、进程优先级、文件描述符、所拥有的资源等。
- 程序段：也被称为代码段，指的是进程所要执行的程序代码。
- 数据段：也称为全局变量区、静态变量区，指的是进程中的数据和堆栈空间。其中数据段包括了全局变量和静态变量，堆是动态分配的内存区，堆的大小不固定并且可以动态增长，在进程中也属于数据段，而栈是记录程序执行状态的内存区，也是数据段的一部分。 除了上述内容以外，进程还会占用一些系统资源，如内存、文件描述符、定时器等。
解析磁盘中的代码如何在计算机上运行的？
磁盘中的代码需要被加载到计算机内存中，才能被计算机CPU执行。下面是代码如何在计算机上运行的一些简要步骤：
- 编写代码：程序员使用各种编程语言（如C、Java、Python等）编写代码。
- 编译或解释代码：代码需要编译或解释后才能被计算机CPU读取和执行。编译器会将程序源码翻译成二进制指令，而解释器则会逐行解释源代码并执行。
- 存储代码：编译或解释后的代码被存储在磁盘中，通常以可执行文件的形式存在，如.EXE、.BIN、.ELF等文件格式。
- 加载代码：存储在磁盘中的可执行文件需要被加载到计算机内存中，以便CPU能够访问程序的代码和数据。操作系统负责加载可执行文件，并将其映射成进程。
- 执行代码：一旦代码被加载到内存中形成进程，即可由CPU执行。CPU会依次执行代码中的指令，直到程序结束。 在代码执行阶段，CPU会对指令进行解码、执行、跳转等操作，将进程中的代码逐行执行，同时还会执行相应的I/O操作等，最终完成软件应用程序的功能。 需要注意的是，在实际的计算机系统中，上述过程可能会受到访问权限、内存限制、硬件环境等因素的影响，在执行代码前还可能需要进行诸如链接、依赖检查等操作。
总结OOM原理，及处理方法。
OOM(Out Of Memory)是指当操作系统不能再足够分配给进程所需内存时，会触发OOM机制，操作系统会尝试释放一些内存资源，并选择终止一些进程来解决内存使用问题。 OOM的原理可以简单地描述如下：
-
当一个操作系统中的进程申请内存时，操作系统会分配给它一段虚拟内存地址空间，并标记为虚拟内存地址空间中的一部分已经被使用。
-
如果操作系统中的进程继续申请内存而操作系统无法再分配更多的物理内存，它就会从已使用的虚拟内存中选择一个部分，将其释放，从而腾出一些内存。
-
如果操作系统无法释放任何已使用的虚拟内存并且仍然无法为该进程分配更多内存，操作系统就会选择杀死一个消耗内存量较大的进程来释放内存。
常见的OOM处理方法包括：
- 内存增加：增加系统内存可以缓解内存问题，并且可以增加系统响应能力和吞吐量。
- 配置虚拟内存：在内存极度紧缺的情况下，可以通过配置虚拟内存，将一部分磁盘空间作为虚拟内存空间使用，来扩充内存容量。
- 杀死进程：由于OOM机制会终止一些进程，因此可以通过杀死占用内存较大的进程来腾出一些内存资源。 4. 优化应用程序：优化应用程序代码设计，包括减少内存分配、避免内存泄露、优化数据结构、缓存数据、关闭不必要的服务等，都有助于降低内存使用。
结合进程管理命令，说明进程各种状态。
ps命令
#ps命令常用于查看进程的当前状态。ps命令输出的STAT字段用于表示进程的状态
R：运行中（Running）。
S：休眠（Sleeping），也称为“可中断睡眠”。
D：不可中断休眠（Uninterruptible sleep）。
T：停止（Stopped）。
Z：僵尸进程（Zombie）。
top命令
#top可以监控系统的进程、CPU、内存等资源占用情况
[root@Rocky8 script]#top
top - 16:23:27 up 3 days, 18:36, 2 users, load average: 0.00, 0.00, 0.00
Tasks: 245 total, 1 running, 244 sleeping, 0 stopped, 0 zombie
running：正在运行的进程。
sleeping：正在等待事件的进程。
stopped：已停止的进程。
zombie：僵尸进程
kill命令
SIGTERM：请求进程终止，通常是正常方式关闭。
SIGKILL：强制结束进程。
#实例
[root@Rocky8 ~]#ping 192.168.188.100
[root@Rocky8 script]#ps aux |grep ping
root 135312 0.0 0.1 242284 2344 pts/0 S+ 16:25 0:00 ping 192.168.188.100
root 135404 0.0 0.0 221940 1100 pts/1 S+ 16:26 0:00 grep --color=auto ping
[root@Rocky8 script]#kill 135312
pkill命令：可以通过进程名、用户ID等信息来找到并杀死进程。
说明IPC通信和RPC通信实现的方式。
IPC（Inter-Process Communication，进程间通信）和 RPC（Remote Procedure Call，远程过程调用）是两种在进程间进行交互的通信方式。
一、IPC通信实现方式：
1. 管道（Pipe）：管道是进程间通信的一种简单方式，允许在两个或多个进程之间传递数据。它主要基于UNIX文件系统中的一种特殊文件类型，可以将一个进程的输出直接发送到另一个进程的输入，从而实现两个进程之间的通信。
2. 信号(Signal)：可以用来通知进程发生了某些事情，如某个进程结束了执行，发生了错误等等。通过使用信号，一个进程可以向其他进程发送一个信号，告诉它某些事情已经发生了，无论是好还是坏。
3. 管理共享内存（Shared Memory）：共享内存允许多个进程访问同一块内存区域，从而允许它们相互交换信息，而不需要使用其他通信方式。共享内存通常被用于大量数据的传输，特别是在高速数据的环境中非常有用。
4. 套接字(Socket)：套接字是在网络中传输数据的一种通用方法。它允许不同的进程在同一网络内传输数据，同时可以进行双向通信，可以通过网络连接远程进程。
二、RPC通信实现方式：
RPC是远程过程调用的意思，在分布式计算中使用RPC来处理远程调用请求。其主要实现方式如下：
1. 远程服务接口定义（Remote Service Interface Definition）：RPC的首要任务是定义远程服务接口，以便客户端应用程序可以透明地调用服务端应用程序。
2. 生成RPC绑定代码（Generating RPC Binding Code）：基于定义的远程服务接口，可以生成必要的RPC绑定代码，使客户端和服务器能够进行通信和相互调用。这些代码最初是由RPC语言编写的，然后被转换为适当的语言和协议。
3. 连接管理（Connection Management）：RPC通信需要建立连接，以便客户端和服务器之间可以通信，客户端会自动建立一个连接对象，连接的管理通常通过TCP/IP来完成。
4. 编码与解码（Encoding and Decoding）：客户端和服务器之间需要进行数据通信，但是它们使用的是不同的内存空间，这意味着要对数据进行编码和解码，在客户机和服务器之间传递调用过程的参数。
通过mkfifo, cat, 来解释秒杀的并发问题，如何通过队列解决的？最好结合图形。说明消息队列的作用？
在FIFO中，用户请求将被排队，直到服务器处理这些请求
所有的请求先被发送到消息队列中，然后服务端按照请求的先后顺序逐个处理这些请求。与FIFO相比，队列还可以有更多的控制选项，例如队列的容量、处理请求的速度等。
消息队列(Message Queue)提供了一种方法，让进程通过一种可靠的、异步的方式发送和接收数据。通过使用消息队列，可以减轻系统资源的压力，实现进程间通信，同时增加系统的可靠性。消息队列的具体作用如下： - 异步传输：消息队列允许发送者异步地将消息发送到队列中，从而可以尽可能快地处理请求，闲置的进程可以立即处理下一条请求。 - 应用解耦：通过使用消息队列，不同的应用程序可以解耦，避免了应用程序之间因解耦不同而导致的侵入性的改变。 - 可靠性：消息队列通常会确保消息被确实传递到队列中，并且仅当消息在队列上被接收方接收时，它才会被删除，从而确保可靠性和数据的一致性。
总结Linux，前台和后台作业的区别，并说明如何在前台和后台中进行状态转换。
前台进程：是在终端中运行的命令，那么该终端就为进程的控制终端，一旦这个终端关闭，这个进程也随之消失。
后台进程：也叫守护进程（Daemon），是运行在后台的一种特殊进程，不受终端控制，它不需要终端的交互；Linux的大多数服务器就是使用守护进程实现的。比如Web服务器的httpd等。
CTRL+z：将正在运行的程序放置后台停止，以便终端的继续使用
jobs：查看后台停止的程序
bg +1：将后台停止状态的进程，变成后台运行的程序
fg：将后台运行的程序放置前台运行
总结内核设计流派及特点。
内核的功能：进程管理、内存管理、网络管理、驱动程序、文件系统、安全功能
内核设计流派：
单内核设计：把所有功能集成于同一个程序，而后每一个功能在就在程序内部使用线程来实现，这就是内核线程，这种设计好处在于大家结合的更紧密，效率高，但是问题在于任何一个地方产生故障可能会影响全局，Linux是这种设计
微内核设计：每一个功能都使用一个独立的子系统实现，而后在找一个中央调配协调系统，当我们用到什么功能时，就让这些子系统彼此间通信来完成任务。每一个子系统都独立运作，我们可以用一个松散框架将它们联合在一起，问题就是可能效率低，但每一个子系统出现问题不至于影响全局。不过，话虽如此，目前来看虽然微内核设计在理论上是先进的，但是由于其内部的协调机制过于复杂，使得它的任何优越性基本上没能体现，Windows，Solaris就是这种设计
特点：
支持模块化：Linux也充分借鉴了微内核设计的思想，内部的各种功能都被做成独立的功能模块而不是子系统，子系统里面可能包括很多模块并且拥有自制机制，而内核模块就像用户空间库的概念，不过库是被应用程序调用的，而内核模块只能被内核调用，文件名称都以.ko结尾（kernel object）。通过模块化也使得Linux内核不会变得过于庞大，用到哪个模块功能就装载哪个
支持模块的动态装、卸载：在线装载、卸载模块
总结rocky 启动流程，grub工作流程
1. BIOS（基本输入输出系统）：加载 BIOS的硬件信息，获取第一个启动设备。
2. MBR（主引导记录）：BIOS 会找到一个指定的硬盘（如/dev/sda），并通过磁盘的第一个扇区中的 MBR（主引导记录）来引导启动。MBR 是一个特殊的分区，它包含了引导加载程序（grub）的启动信息
3. GRUB（GRand Unified Bootloader）：MBR 内的引导程序启动后，会加载 bootloader（启动加载程序），CentOs6 使用的是 GRUB。GRUB 提供了启动选项的选择、内核和模块的加载等功能。
4. 内核加载：通过 GRUB 选择操作系统后，GRUB 会找到相应的内核文件 vmlinuz。接着，GRUB 会将内核文件从硬盘中加载到内存中。
5. 内核初始化：内核文件加载到内存中后，控制权交给内核。内核被加载后，开始初始化系统并加载必要的模块，如硬件驱动程序、内存管理、文件系统等等。
6. 启动第一个用户空间进程：当内核初始化完成以后，它会启动第一个用户态进程 init，接下来所有的用户进程都由 init 进程来管理。
#在以上启动流程中，grub的工作流程如下：
1. 加载 grub.conf 文件：GRUB的配置文件为 grub.conf，它通常存放在/boot/grub目录下。在启动时，GRUB 会读取该配置文件。
2. 显示启动菜单：根据 grub.conf 文件，GRUB 会显示启动菜单，让用户选择需要启动的操作系统。
3. 加载内核：GRUB会在菜单中读取用户选择的要启动的内核文件，并将其加载到内存中。
4. 加载 initramfs 文件：当内核文件被加载到内存中后，GRUB 会一同加载 initramfs 文件，该文件包含了一些必要的模块和工具，用于内核启动前的初始化过程。
5. 控制权交给内核：GRUB 会将控制权交给内核，由内核来进一步初始化系统和加载必要的模块。
总结为POST（上电自检）
–GRUB 1阶段MBR446–GRUB1.5MBR之后的空间（提供grub2文件所有分区的文件系统）
–GRUB 2阶段（grub.conf）
–kernel(initramfs.img)–根分区–/sbin/init–/etc/inittab–/etc/rc.sysinit（系统初始化脚本）
–/etc/rc.d/rc–/etc/rcN.d/K,S(/etc/init.d/)–/etc/rc.local–login登录
手写chkconfig服务脚本，可以实现服务的开始，停止，重启。
总结systemd服务配置文件
/usr/lib/systemd/system #每个服务最主要的启动脚本设置
/lib/systemd/system #ubuntu的对应目录，兼容于centOS7，8和Ubuntu
/run/systemd/system #系统执行过程中所产生的服务脚本，比上面目录优先运行
/etc/systemd/system #管理员创建的执行脚本
总结system启动流程
UEF或BIOS初始化，运行POST开机自检
选择启动设备
引导装载程序，centOS7是grub2加载程序的配置文件：
/etc/grub.d/
/etc/default/grub
/boot/grub2/grub.cfg
加载initramfs驱动模块（可以实现根文件系统的挂载）
加载内核选项
内核初始化，centOS使用systemd代替init
执行initrd.target所有单元，包括挂载/etc/fstab
从initasmfs根文件系统切换到磁盘根目录
systemd执行默认target配置，配置文件/etc/systemd/system/default.target
systemd执行sysinit.target初始化系统及basic.target准备操作系统
systemd启动multi-user.target下的本机于服务器服务
systemd执行multi-user.target下的/etc/rc.d/rc.local
ststemd执行multi-user.target下的getty.target及登录服务
systemd执行graphical需要的服务
总结awk工作原理，awk命令，选项，示例。
awk工作原理
逐行读取文本，默认以空格或tab键为分隔符进行分隔，将分隔所得的各个字段保存到内建变量中，并按模式
或者条件执行编辑命令
awk命令：
awk [-F field-separator] 'commands' input-file(s)其中，commands 是真正awk命令，[-F域分隔符]是可选的。 input-file(s) 是待处理的文件。在awk中，文件的每一行中，由域分隔符分开的每一项称为一个域。通常，在不指名-F域分隔符的情况下，默认的域分隔符是空格。
awk 内置变量
awk 运算符
范例：
[root@centos8 ~]# awk -F ":" '{print $1,$3}' /etc/passwd
root 0
bin 1
daemon 2
adm 3
lp 4
sync 5
shutdown 6
halt 7
mail 8
operator 11
#输出第3个字段的值小于5的第1、3个字段内容
[root@centos8 ~]# awk -F ":" '$3<5{print $1,$3}' /etc/passwd
root 0
bin 1
daemon 2
adm 3
lp 4
#查看当前内存使用百分比
[root@centos8 ~]# free -m | awk '/Mem:/ {print int($3/$2*100)"%"}'
39%
#查看当前CPU空闲率，（-b -n 1 表示只需要1次的输出结果）
[root@centos8 ~]# top -b -n 1 | grep Cpu | awk -F ',' '{print $4}' | awk '{print $1}'
97.1
总结awk的数组，函数。
数组：
# 去重
root@Ubuntu:~# cat /data/test.txt
a
b
c
a
b
c
a
b
c
d
r
s
d
root@Ubuntu:~# awk '!line[$0]++' /data/test.txt
a
b
c
d
r
s
函数：
# 生成随机数
root@Ubuntu:~# awk 'BEGIN{srand();print rand()}'
0.0253289
root@Ubuntu:~# awk 'BEGIN{srand();print rand()}'
0.778805
# 1-100随机数
root@Ubuntu:~# awk 'BEGIN{srand();print int(rand()*100)}'
71
root@Ubuntu:~# awk 'BEGIN{srand();print int(rand()*100)}'
94
字符串处理
length([s])：返回指定字符串长度
sub(r,s,[t])：对t字符串搜索r表示模式匹配的内容，并将第一个匹配的内容替换成s，懒惰模式
gsub(r,s,[t])：对t字符串进行搜索r表示的模式匹配的内容，并全部替换为s所表示的内容
split(s,array,[r])：以r为分割符，切割字符串s，并将切割后的结果保存至array所表示的数组中，第一个索引值为1，第二人格索引值为2...
system（）：括号里能执行linux命令
systime（）：当前时间到1970-1-1的秒数
strftime（）：指定时间格式
# 自定义函数
形参：定义函数时的参数，占位符
实参：使用函数实际正在使用的参数
root@Ubuntu:~# cat /data/a.awk
BEGIN{print strftime("%Y-%m-%d T%H:%M",systime())}
root@Ubuntu:~# awk -f /data/a.awk
2023-02-15 T14:23
root@Ubuntu:~# cat test.awk
function max(x,y) {
x>y?var=x:var=y
return var
}
BEGIN{print max(a,b)}
root@Ubuntu:~# awk -v a=10 -v b=30 -f test.awk
30
root@Ubuntu:~# awk -v a=100 -v b=30 -f test.awk
100
总结ca管理相关的工具，根据使用场景总结示例。
ca相当于中间人的角色
# 创建文件
[root@localhost ~]# mkdir /etc/pki/CA/certs
[root@localhost ~]# mkdir /etc/pki/CA/newcerts
[root@localhost ~]# mkdir /etc/pki/CA/crl
[root@localhost ~]# mkdir /etc/pki/CA/private
[root@localhost ~]# tree /etc/pki/CA
/etc/pki/CA
├── certs
├── crl
├── newcerts
└── private
# 创建私有CA
#生成证书索引数据库文件
touch /etc/pki/CA/index.txt
#指定第一个变法证书的序列号
echo 01 > /etx/pki/CA/serial
# 生成CA私钥
cd /etc/pki/CA
(umask 066;openssl genrsa -out /private/cakey.pem 2048)
# 生成CA自签名证书
openssl req -new -x509 -key /etc/pki/CA/private/cakey.pem -days 3650 -out /etc/pki/CA/cacert.pem
#选项说明
-new :生成新证书签署请求
-x509:专用于CA生成自签证书
-key:生成请求时用到的私钥文件
-days n:证书的有效期限
-out /PATH/TO/SOMECERTFILE:证书的保存路径
国家代码：https://country-code.cl/
# 将生成的CA自签名证书变成可读
[root@localhost CA]# openssl x509 -in /etc/pki/CA/cacert.pem -noout -text
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
51:a7:af:51:f2:66:17:63:ac:a2:4d:7e:48:29:60:e8:e5:8a:ff:59
Signature Algorithm: sha256WithRSAEncryption
Issuer: C = CN, ST = shanghai, L = shanghai, O = magedu, OU = xie1, CN = ca.magedu.org, emailAddress = [email protected]
Validity
Not Before: Feb 16 06:12:58 2023 GMT
Not After : Feb 13 06:12:58 2033 GMT
Subject: C = CN, ST = shanghai, L = shanghai, O = magedu, OU = xie1, CN = ca.magedu.org, emailAddress = [email protected]
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
Modulus:
00:cf:a9:99:0d:ac:a9:c0:d7:ba:05:7f:5e:ae:8c:
7b:d8:df:f4:3d:63:50:02:2d:1b:d9:b2:19:bb:e6:
c3:0d:20:49:62:1e:5a:d9:ae:a9:59:6d:c0:f4:f2:
38:74:af:8e:5d:43:d4:11:4d:6a:c7:4c:83:33:2e:
0d:ca:ce:b4:ea:25:d1:bd:46:32:a9:09:ef:ab:4d:
ae:d9:81:d2:9d:8c:9b:f2:80:7b:f1:e1:f1:23:0b:
2d:70:7b:29:28:14:51:4f:e2:c9:1a:ae:b5:ad:ea:
12:43:fb:8b:ef:e0:dd:fc:70:52:2d:59:fe:05:a3:
dd:85:03:30:31:20:a8:41:41:13:d6:cc:ac:ae:ff:
e1:3a:4e:0f:cc:7a:85:a2:4a:ba:a4:e7:df:9b:d8:
0e:44:e4:e8:cd:f7:9c:c2:a8:b4:82:a5:3c:41:f2:
5e:31:d7:ef:c9:32:6e:0a:71:72:78:f7:31:f1:0b:
29:e4:b4:f9:ce:47:5e:09:c7:66:8a:d9:df:0e:4f:
64:6d:78:51:37:c6:ba:4f:27:ba:a8:30:89:5d:c8:
e3:8c:f4:75:9b:b8:61:8e:cd:5f:72:48:ea:6e:ab:
27:55:58:3f:f9:e7:1f:96:85:bb:af:a3:1f:a6:69:
b0:94:ad:30:62:9c:7e:a4:12:1e:2a:11:9d:03:d8:
b1:61
Exponent: 65537 (0x10001)
X509v3 extensions:
X509v3 Subject Key Identifier:
E4:D1:82:D3:5C:F7:DB:22:A5:CF:FD:7A:23:FF:8A:D1:71:C9:E0:3D
X509v3 Authority Key Identifier:
E4:D1:82:D3:5C:F7:DB:22:A5:CF:FD:7A:23:FF:8A:D1:71:C9:E0:3D
X509v3 Basic Constraints: critical
CA:TRUE
Signature Algorithm: sha256WithRSAEncryption
Signature Value:
82:49:79:81:f6:4a:6e:4a:1c:01:c9:c2:3b:b8:c5:97:79:8b:
e5:8c:ef:c2:44:9a:3e:4b:2e:de:97:64:15:7d:b9:44:c3:5c:
42:16:eb:ff:f9:34:ba:ba:53:ac:b0:10:93:ff:0f:b2:ba:96:
7b:d3:75:58:10:ca:2f:7d:52:d5:5b:96:8b:18:35:d8:99:41:
c6:fe:e1:9a:a6:58:df:2f:be:47:68:ea:ee:1b:af:bd:9c:94:
58:ae:1a:4d:a1:a8:2d:ac:06:88:cd:ec:ce:b1:e8:98:d7:81:
e5:9c:73:94:96:fd:d9:1b:cf:87:fd:01:af:55:10:8a:35:e5:
7e:86:15:45:a8:b4:59:62:01:62:28:d1:34:9a:58:03:f0:7a:
a6:3b:79:63:b5:eb:2a:ee:af:a4:4c:27:8e:e0:7d:4f:ec:c5:
cf:26:a3:c4:f4:a1:4f:1d:39:f7:85:6e:34:68:73:ea:48:2a:
3b:a0:de:80:d5:75:f9:dc:0e:70:63:4e:76:0f:90:b1:75:1a:
88:0f:80:9c:50:a0:3c:9d:b0:84:36:98:ac:58:95:ff:fa:57:
72:41:02:93:3d:23:bd:1f:fe:79:a8:b9:e4:e0:5a:36:af:14:
42:f2:88:47:18:40:dc:e9:00:f1:8b:4f:84:19:b8:54:06:7b:
dd:1f:2e:2d
# 申请证书并颁发证书
为需要使用证书的主机生成私钥
(umask 066; openssl genrsa -out /data/test.key 2048
为需要使用证书的主机生成证书申请文件
openssl req -new -key /data/test.key -out /data/test.csr
在CA签署证书并将证书颁发给请求者
openssl ca -in /data/test.csr -out /etc/pki/CA/certs/test.crt -days 100
注意：默认要求国家、省、公司名称必须一致
查看证书中的信息
openssl x509 -in /etc/pki/CA/cacert.pem -noout -text
#查看指定编号的证书状态
openssl ca -status SERIAL
# 吊销证书
在客户端获取要吊销的证书serial
openssl x509 -in /etc/pki/CA/cacert.pem -noout -serial -subject
在CA上，根据客户提交的serial与subject信息，对比校验是否与index.txt文件中的信息一致，吊销证书
openssl ca -revoke /etc/pki/CA/newcerts/SERIAL.pem
指定第一个吊销证书的编号，注意：第一次更新吊销列表前，才需要执行
echo 01 > /etc/pki/CA/crlnumber
更新吊销证书列表
openssl ca -gencrl -out /etc/pki/CA/crl.pem
查看crl文件
openssl crl -in /etc/pki/CA/crl.pem -noout -test
总结对称加密和非对称加密算法和用openssl签发证书步骤
#1生成公钥私钥
[root@localhost ~]# ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Created directory '/root/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa
Your public key has been saved in /root/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:ILFr4RV2VR5YUS86yoYCiV0PEHZU17wvOzUWpe1LGNk [email protected]
The key's randomart image is:
+---[RSA 3072]----+
| =o=.o.o*=o. |
| . * o ...o. ..|
| + = ..++.|
| + B + .+oE.|
| . B S o.oo |
| . . o ..o=..|
| . . + =...|
| . . o . |
| . |
+----[SHA256]-----+
[root@localhost ~]# ls .ssh
id_rsa id_rsa.pub
#2。自己连接自己
[root@localhost ~]# ssh-copy-id 192.168.100.134
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
[email protected]'s password:
Number of key(s) added: 1
Now try logging into the machine, with: "ssh '192.168.100.134'"
and check to make sure that only the key(s) you wanted were added.
[root@localhost ~]# ll .ssh
total 20
-rw------- 1 root root 580 Feb 16 16:11 authorized_keys
-rw------- 1 root root 2610 Feb 16 15:59 id_rsa
-rw-r--r-- 1 root root 580 Feb 16 15:59 id_rsa.pub
-rw------- 1 root root 843 Feb 16 16:11 known_hosts
-rw-r--r-- 1 root root 97 Feb 16 16:00 known_hosts.old
drwx------ 2 root root 48 Feb 16 16:02 ssh-copy-id.PKjkIpzwnF
#3.将文件夹拷贝到要连接的机器中
[root@localhost ~]# scp -r .ssh 192.168.100.131:/root/
The authenticity of host '192.168.100.131 (192.168.100.131)' can't be established.
ED25519 key fingerprint is SHA256:0GW9Izhoa5yHVB24Adba3W+ko86HUDeDw8lROo2GM6c.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '192.168.100.131' (ED25519) to the list of known hosts.
[email protected]'s password:
id_rsa 100% 2610 1.3MB/s 00:00
id_rsa.pub 100% 580 1.1MB/s 00:00
known_hosts 100% 1686 3.8MB/s 00:00
popids_tmp_id 100% 580 1.4MB/s 00:00
popids_output 100% 92 126.9KB/s 00:00
authorized_keys 100% 580 1.4MB/s 00:00
known_hosts.old 100% 940 2.2MB/s 00:00